The result with the given left position and right position
which left and right tag is asymmetric will be involved in the operation

@param leftPos
@param rightPos
@return
174005
public E asymms(Integer leftPos, Integer rightPos) {
		return asymm(leftPos, rightPos).result();
	}
914201
public static Slice leftTrim(Slice utf8, int[] whiteSpaceCodePoints)
    {
        int length = utf8.length();

        int position = firstNonMatchPosition(utf8, whiteSpaceCodePoints);
        return utf8.slice(position, length - position);
    }
1030789
public static GeoEquals geoEquals(Expression<Geometry> left, Expression<Geometry> right) {
        return new GeoEquals(left, right);
    }
673465
public static Expression firstNonNull(final Expression left, final Expression right) {
    checkArgument(left.resultType().getSort() == Type.OBJECT);
    checkArgument(right.resultType().getSort() == Type.OBJECT);
    Features features = Features.of();
    if (Expression.areAllCheap(left, right)) {
      features = features.plus(Feature.CHEAP);
    }
    if (right.isNonNullable()) {
      features = features.plus(Feature.NON_NULLABLE);
    }
    return new Expression(left.resultType(), features) {
      @Override
      protected void doGen(CodeBuilder cb) {
        Label leftIsNonNull = new Label();
        left.gen(cb); // Stack: L
        cb.dup(); // Stack: L, L
        cb.ifNonNull(leftIsNonNull); // Stack: L
        // pop the extra copy of left
        cb.pop(); // Stack:
        right.gen(cb); // Stack: R
        cb.mark(leftIsNonNull); // At this point the stack has an instance of L or R
      }
    };
  }
341872
protected Expression reOrder(Expression left, Expression right, BinaryOperation.Op op) {
        if (right instanceof BinaryOperation) {
            BinaryOperation rightOp = (BinaryOperation) right;
            if (!rightOp.isSealed() && rightOp.getOp().getPriority() == op.getPriority()) {
                replaceLeft(rightOp, left, op);
                return right;
            }
        }
        return new BinaryOperation(op, left, right);
    }
460544
public AsymmMultiPos<S, String, String> betn(String left, String right) {
		return new AsymmMultiPos<S, String, String>(left, right) {

			@Override protected S result() {
				if (Strs.isEmpty(asymmLR)) {
					return aQueue('S', left, right, pos, position, inclusive, plusminus, filltgt);
				} else { return aQueue('Z', left, right, pos, asymmLR, inclusive, plusminus, filltgt); }
			}
		};
	}
849156
public List<JavaComment> leftAlign(List<JavaComment> originals) {
        final List<JavaComment> results = new ArrayList<JavaComment>(
                originals.size());
        for (JavaComment original : originals) {
            results.add(original
                    .match(new JavaComment.MatchBlock<JavaComment>() {

                        @Override
                        public JavaComment _case(JavaDocComment x) {
                            final List<JDToken> leadingWhiteSpace = new ArrayList<JDToken>(1);
                            final LeftAlignState state[] = new LeftAlignState[] { LeftAlignState.IN_LINE };
                            return _JavaDocComment(x.start, leftAlignSection(x.generalSection, x.tagSections.isEmpty(), leadingWhiteSpace, state), leftAlignSections(x.tagSections, leadingWhiteSpace, state), x.end);
                        }


                        @Override
                        public JavaComment _case(JavaBlockComment x) {
                            return _JavaBlockComment(leftAlignBlock(x.lines));
                        }

                        @Override
                        public JavaComment _case(JavaEOLComment x) {
                            return x;
                        }
                    }));
        }
        return results;        
    }
708914
public static <L, R> @NonNull Pair<L, R> left(final @Nullable L left) {
    return of(left, null);
  }
228955
public static Slice rightTrim(Slice utf8, int[] whiteSpaceCodePoints)
    {
        int position = lastNonMatchPosition(utf8, 0, whiteSpaceCodePoints);
        return utf8.slice(0, position);
    }
585510
protected Node simpleAssignment(Node left, Node right) {
        int nodeType = left.getType();
        switch (nodeType) {
          case Token.NAME:
              String name = ((Name) left).getIdentifier();
              if (inUseStrictDirective &&
                  ("eval".equals(name) || "arguments".equals(name)))
              {
                  reportError("msg.bad.id.strict", name);
              }
              left.setType(Token.BINDNAME);
              return new Node(Token.SETNAME, left, right);

          case Token.GETPROP:
          case Token.GETELEM: {
              Node obj, id;
              // If it's a PropertyGet or ElementGet, we're in the parse pass.
              // We could alternately have PropertyGet and ElementGet
              // override getFirstChild/getLastChild and return the appropriate
              // field, but that seems just as ugly as this casting.
              if (left instanceof PropertyGet) {
                  obj = ((PropertyGet)left).getTarget();
                  id = ((PropertyGet)left).getProperty();
              } else if (left instanceof ElementGet) {
                  obj = ((ElementGet)left).getTarget();
                  id = ((ElementGet)left).getElement();
              } else {
                  // This branch is called during IRFactory transform pass.
                  obj = left.getFirstChild();
                  id = left.getLastChild();
              }
              int type;
              if (nodeType == Token.GETPROP) {
                  type = Token.SETPROP;
                  // TODO(stevey) - see https://bugzilla.mozilla.org/show_bug.cgi?id=492036
                  // The new AST code generates NAME tokens for GETPROP ids where the old parser
                  // generated STRING nodes. If we don't set the type to STRING below, this will
                  // cause java.lang.VerifyError in codegen for code like
                  // "var obj={p:3};[obj.p]=[9];"
                  id.setType(Token.STRING);
              } else {
                  type = Token.SETELEM;
              }
              return new Node(type, obj, id, right);
          }
          case Token.GET_REF: {
              Node ref = left.getFirstChild();
              checkMutableReference(ref);
              return new Node(Token.SET_REF, ref, right);
          }
        }

        throw codeBug();
    }
566383
public static Object add(Object left, Object right) {
        return InfixOpNode.add(left, right, null);
    }
1234557
public static AxisAlignedBB identity(BlockPos pos)
	{
		return new AxisAlignedBB(pos.getX(), pos.getY(), pos.getZ(), pos.getX() + 1, pos.getY() + 1, pos.getZ() + 1);
	}
100782
public AsymmMultiPos<E, L, R> asymm(Integer leftPos, Integer rightPos) {
		this.asymmLR = new StringBuilder().
			append(checkNotNull(leftPos)).append(Strs.WHITE_SPACE).
			append(checkNotNull(rightPos)).toString();
		return this;
	}
687055
public static boolean areEqualTrimmed(final String left, final String right)
   {
      if ((left != null) && (right != null))
      {
         return left.trim().equals(right.trim());
      }
      return areEqual(left, right);
   }
962652
public static BooleanIsNotEqual isNotEqual(ComparableExpression<Boolean> left, ComparableExpression<Boolean> right) {
        return new BooleanIsNotEqual(left, right);
    }
645361
public static AxisAlignedBB empty(BlockPos pos)
	{
		return new AxisAlignedBB(pos.getX(), pos.getY(), pos.getZ(), pos.getX(), pos.getY(), pos.getZ());
	}
608357
public static ExprDouble toExprDouble(Expression left, Expression right, int operation) {
	return new OpDouble(left, right, operation);
    }