両面待ちだったかを判定するため
一つ一つの順子と最後の牌について判定する

@param shuntsu 判定したい順子
@param last    最後の牌
@return 両面待ちだったか
435466
private boolean isRyanmen(Shuntsu shuntsu, Tile last) {
        //ラスト牌と判定したい順子のtypeが違う場合はfalse
        if (shuntsu.getTile().getType() != last.getType()) {
            return false;
        }

        int shuntsuNum = shuntsu.getTile().getNumber();
        int lastNum = last.getNumber();
        if (shuntsuNum == 2 && lastNum == 1) {
            return true;
        }

        if (shuntsuNum == 8 && lastNum == 9) {
            return true;
        }

        int i = shuntsuNum - lastNum;
        if (i == 1 || i == -1) {
            return true;
        }

        return false;
    }
628673
public Command undoLast() {
        Command lastCommand = undoStack.pop();
        redoStack.push(lastCommand);
        lastCommand.undo();
        return lastCommand;
    }
643540
def _last_values(self):
        
        if not self.session.get('last_request_uri'):
            self.session.last_request_uri = None
        self.session.last_request_at = self.session.get('last_request_at', 0)
1228945
public static String getLastCharacters(String s, int last) {
        int index = s.length() - last + 1;
        if (index < 0) {
            index = 0;
        }
        String result = "";
        if (index > 0) {
            result = " ... ";
        }
        result = result +  s.substring(index);
        return result;
    }
1224021
private R connectOne(T first, R acc, T last) {
        synchronized (root) {
            Connector<T, R> l = left;
            if (l == null) {
                return pushRight(acc, last);
            }
            if (l.acc == NONE) {
                l.acc = acc;
                l.left = first;
                l.right = last;
                return connectEmpty();
            }
            T laright = l.right;
            if (mergeable.test(laright, first)) {
                l.acc = combiner.apply(l.acc, acc);
                l.right = last;
                return connectEmpty();
            }
            left = null;
            l.rhs = null;
            l.right = none();
            if (l.left != NONE) {
                return pushRight(acc, last);
            }
            acc = pushRight(acc, last);
            if (acc != NONE)
                left = new Connector<>(null, acc, this);
            return l.drain();
        }
    }
289154
public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }
890729
public static <T> T last( List<T> list )
    {
        return get( list, list.size() - 1 );
    }
1065350
public static String stripLastSlash(String inputString) {
        if (null == inputString) {
            return null;
        }
        String rc = inputString.trim();
        int len = rc.length();
        if (0 < len) {
            char lastChar = rc.charAt(len - 1);
            if ('/' == lastChar || '\\' == lastChar) {
                rc = rc.substring(0, len - 1);
            }
        }

        return rc;
    }
1373397
def set_last_position(self, last_position):
        
        self.last_position = last_position
        if last_position is not None and last_position.get('last_read') is not None:
            self.last_read = last_position['last_read']
        else:
            self.last_read = -1
            self.last_position = {
                'last_read': self.last_read
            }
1075855
public boolean lastChild() {
        if (mNode == null || mNode.getChildCount() < 1) {
            return false;
        }
        for (int i = mNode.getChildCount() - 1; i >= 0; --i) {
            AccessibilityNodeInfoCompat newNode = mNode.getChild(i);
            if (newNode == null) {
                return false;
            }
            if (AccessibilityNodeInfoUtils.isVisibleOrLegacy(newNode)) {
                reset(newNode);
                return true;
            }
            newNode.recycle();
        }
        return false;
    }
91080
function(lastope){
		// 前回と同じ場所なら前回の更新のみ
		var property = this.property;
		if( lastope.group    === this.group &&
			lastope.property === this.property  &&
			lastope.num      === this.old   &&
			lastope.bx       === this.bx    &&
			lastope.by       === this.by    &&
			(property === 'qnum'  || 
			 property === 'qnum2' ||
			 property === 'qchar' ||
			 property === 'anum'  ||
			(property === 'snum' && lastope.pos === this.pos))
		)
		{
			lastope.num = this.num;
			return true;
		}
		return false;
	}
50128
public static <T> T last(List<T> lst) {
        if (lst == null || lst.isEmpty()) return null;
        return lst.get(lst.size() - 1);
    }
1009128
public void last(String name, float value) {
		Counter counter = get(name, CounterType.LastValue);
		counter.setLast(value);
		update();
	}
1070970
public T removeLast() {
        if ( this.lastNode == null ) {
            return null;
        }
        final T node = this.lastNode;
        this.lastNode = node.getPrevious();
        node.setPrevious( null );
        if ( this.lastNode != null ) {
            this.lastNode.setNext( null );
        } else {
            this.firstNode = null;
        }
        this.size--;
        return node;
    }
282795
public ObjectSinkNode removeLast() {
        if ( this.lastNode == null ) {
            return null;
        }
        final ObjectSinkNode node = this.lastNode;
        this.lastNode = node.getPreviousObjectSinkNode();
        node.setPreviousObjectSinkNode( null );
        if ( this.lastNode != null ) {
            this.lastNode.setNextObjectSinkNode( null );
        } else {
            this.firstNode = this.lastNode;
        }
        this.size--;
        return node;
    }
69950
function getLastChild(elem) {
        //Current element has children, need to go deeper and get last child as a text node
        if (elem.lastChild.children && elem.lastChild.children.length > 0) {
          return getLastChild(Array.prototype.slice.call(elem.children).pop());
        }
        //This is the absolute last child, a text node, but something's wrong with it. Remove it and keep trying
        else if (!elem.lastChild || !elem.lastChild.nodeValue || elem.lastChild.nodeValue === '' || elem.lastChild.nodeValue == opt.truncationChar) {
          elem.lastChild.parentNode.removeChild(elem.lastChild);
          return getLastChild(element);
        }
        //This is the last child we want, return it
        else {
          return elem.lastChild;
        }
      }
186460
@Nullable
  public static String getLastToken (@Nullable final String sStr, final char cSearch)
  {
    final int nIndex = getLastIndexOf (sStr, cSearch);
    return nIndex == StringHelper.STRING_NOT_FOUND ? sStr : sStr.substring (nIndex + 1);
  }