Links left and right symbols together, i.e. removes this symbol from the string, also removing
any old digram from the hash table.

@param left the left symbol.
@param right the right symbol.
426876
public static void join(SAXSymbol left, SAXSymbol right) {

    // System.out.println(" performing the join of " + getPayload(left) + " and "
    // + getPayload(right));

    // check for an OLD digram existence - i.e. left must have a next symbol
    // if .n exists then we are joining TERMINAL symbols within the string, and must clean-up the
    // old digram
    if (left.n != null) {
      // System.out.println(" " + getPayload(left)
      // + " use to be in the digram table, cleaning up");
      left.deleteDigram();
    }

    // re-link left and right
    left.n = right;
    right.p = left;
  }
1113925
protected function addInlineCodeTags($left, $right)
	{
		$startPos = $left['pos'];
		$startLen = $left['len'] + $left['trimAfter'];
		$endPos   = $right['pos'] - $right['trimBefore'];
		$endLen   = $right['len'] + $right['trimBefore'];
		$this->parser->addTagPair('C', $startPos, $startLen, $endPos, $endLen);
		$this->text->overwrite($startPos, $endPos + $endLen - $startPos);
	}
1160101
public void setLeftRight(Expression l, Expression r)
  {
    m_left = l;
    m_right = r;
    l.exprSetParent(this);
    r.exprSetParent(this);
  }
977407
public static function merge($left, $right)
	{
		if (is_array($left) && is_array($right)) {
			foreach ($left as $key => $val) {
				if (is_int($key)) {
					$right[] = $val;
				} else {
					if (isset($right[$key])) {
						$val = static::merge($val, $right[$key]);
					}
					$right[$key] = $val;
				}
			}

			return $right;

		} elseif ($left === NULL && is_array($right)) {
			return $right;

		} else {
			return $left;
		}
	}
68341
public final void acceptBoth(Consumer<? super L> left, Consumer<? super R> right, L defaultLeft, R defaultRight) {
		left.accept(isLeft() ? getLeft() : defaultLeft);
		right.accept(isRight() ? getRight() : defaultRight);
	}
88543
public Diff compare(String left, String right) {
		return compare(getCtType(left), getCtType(right));
	}
137418
public static DefinitelyAssignedSet join(DefinitelyAssignedSet left, DefinitelyAssignedSet right) {
		if(left == null && right == null) {
			return null;
		} else if(left == null) {
			return right;
		} else if(right == null) {
			return left;
		} else {
			return left.join(right);
		}
	}
687035
public boolean process( T left , T right ) {
//		System.out.println("----------- Process --------------");

		this.inputLeft = left;
		this.inputRight = right;

		tick++;
		trackerLeft.process(left);
		trackerRight.process(right);

		if( first ) {
			addNewTracks();
			first = false;
		} else {
			mutualTrackDrop();
			selectCandidateTracks();
			boolean failed = !estimateMotion();
			dropUnusedTracks();

			if( failed )
				return false;

			int N = matcher.getMatchSet().size();

			if( modelRefiner != null )
				refineMotionEstimate();

			if( thresholdAdd <= 0 || N < thresholdAdd ) {
				changePoseToReference();
				addNewTracks();
			}
		}
		return true;
	}
32978
public void addRightWhere(int left, IntBitSet result) {
        if (line[left] != null) {
            result.addAll(line[left]);
        }
    }
1358239
public void setImages( Input left , Input right ) {
		InputSanityCheck.checkSameShape(left, right);

		this.left = left;
		this.right = right;
	}
1326807
public List<CellFiller> cell(final Symbol left, final Symbol right) {
    final List<CellFiller> cell = table.get(left, right);
    if (cell != null) {
      return cell;
    } else {
      return ImmutableList.of();
    }
  }
281823
static void doDifference(
            Map<String, String> left,
            Map<String, String> right,
            Map<String, String> onlyOnLeft,
            Map<String, String> onlyOnRight,
            Map<String, String> updated
    ) {
        onlyOnRight.clear();
        onlyOnRight.putAll(right);
        for (Map.Entry<String, String> entry : left.entrySet()) {
            String leftKey = entry.getKey();
            String leftValue = entry.getValue();
            if (right.containsKey(leftKey)) {
                String rightValue = onlyOnRight.remove(leftKey);
                if (!leftValue.equals(rightValue)) {
                    updated.put(leftKey, leftValue);
                }
            } else {
                onlyOnLeft.put(leftKey, leftValue);
            }
        }
    }
953536
public final void mLEFT() throws RecognitionException {
		try {
			int _type = LEFT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// hql.g:41:6: ( 'left' )
			// hql.g:41:8: 'left'
			{
			match("left"); if (state.failed) return;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
566383
public static Object add(Object left, Object right) {
        return InfixOpNode.add(left, right, null);
    }
906124
public static <K,V> Set<K> keysDifference(Map<K,V> left, Map<K,V> right) {
        if (left == null){
            return Collections.emptySet();
        }

        if (right == null){
            return left.keySet();
        }

        return Sets.difference(left.keySet(), right.keySet());
    }
1217205
public static boolean lessThan(SoyValue left, SoyValue right) {
    if (left instanceof SoyString && right instanceof SoyString) {
      return left.stringValue().compareTo(right.stringValue()) < 0;
    } else if (left instanceof IntegerData && right instanceof IntegerData) {
      return left.longValue() < right.longValue();
    } else {
      return left.numberValue() < right.numberValue();
    }
  }
450109
public static Object div(Object left, BigDecimal right) {
        return right == null || right.signum() == 0 ? null : InfixOpNode.div(left, right, null);
    }