`index` stores the character number we are currently at while `length` is a constant All of the gobbles below will modify `index` as we move along
160110
function() {
        var ch_i, node;
        ch_i = exprICode(index);

        if (ch_i === OPAREN_CODE) {
          node = gobbleGroup();
        } else {
          node = gobbleIdentifier();
        }
        gobbleSpaces();
        ch_i = exprICode(index);
        while (
          ch_i === PERIOD_CODE ||
          ch_i === OBRACK_CODE ||
          ch_i === OPAREN_CODE
        ) {
          index++;
          if (ch_i === PERIOD_CODE) {
            gobbleSpaces();
            node = {
              type: code.MEMBER_EXP,
              computed: false,
              object: node,
              property: gobbleIdentifier()
            };
          } else if (ch_i === OBRACK_CODE) {
            node = {
              type: code.MEMBER_EXP,
              computed: true,
              object: node,
              property: gobbleExpression()
            };
            gobbleSpaces();
            ch_i = exprICode(index);
            if (ch_i !== CBRACK_CODE) {
              throwError("Unclosed [", index);
            }
            index++;
          } else if (ch_i === OPAREN_CODE) {
            // A function call is being made; gobble all the arguments
            node = {
              type: code.CALL_EXP,
              arguments: gobbleArguments(CPAREN_CODE),
              callee: node
            };
          }
          gobbleSpaces();
          ch_i = exprICode(index);
        }
        return node;
      }
980940
private void prependValueLength(int value, int index) {
    int initialValue = toIntUnsigned(getValue(index));
    int length = toIntUnsigned(getLength(index));
    setValue(index, (short) value);
    setLength(index, (short) (initialValue - value + length));
  }
1027250
def follow_char(self, label, index):
        ""
        offset = units.offset(self._units[index])
        next_index = (index ^ offset ^ label) & units.PRECISION_MASK

        if units.label(self._units[next_index]) != label:
            return None

        return next_index
289418
function indexOfWidth(stringWidth, str, width) {
	if (stringWidth === false)
		return width;
	for (var i = 0; i <= str.length; i++) {
		if (getWidth(stringWidth, str.substr(0, i)) > width)
			return i - 1;
	}
	return str.length;
}
1295422
function indexOf(haystack, needle, i) {
    if (!Buffer.isBuffer(needle)) needle = new Buffer(needle);
    if (typeof i === 'undefined') i = 0;
    var l = haystack.length - needle.length + 1;
    while (i<l) {
      var good = true;
      for (var j=0, n=needle.length; j<n; j++) {
        if (haystack[i+j] !== needle[j]) {
          good = false;
          break;
        }
      }
      if (good) return i;
      i++;
    }
    return -1;
  }
179379
static private int indexOfNthOccurrenceOfCharIn(String str, char ch, int n) {
        boolean inMiddleOfQuote = false;
        int index = -1, previousIndex = 0;
        for (int i=0; i < n; i++) {
            do {
                index = str.indexOf(ch, index+1);
                if (index < 0) {
                    return -1;
                }
                if (hasOddNumberOfSingleQuotes(str.substring(previousIndex, index))) {
                    inMiddleOfQuote = !inMiddleOfQuote;
                }
                previousIndex = index;
            } while (inMiddleOfQuote);
        }
        return index;
    }
1029025
def check_index(self, key, *, index):
        
        self.append({
            "Verb": "check-index",
            "Key": key,
            "Index": extract_attr(index, keys=["ModifyIndex", "Index"])
        })
        return self
1266531
def next(self):
    "  "

    char = self.char
    if char == '\n':
      self.lineno += 1
      self.colno = 0
    else:
      self.colno += 1
    self.index += 1
    return self.char
978943
long prevSetBit(long index) {
		assert index >= 0 && index < numBits : "index=" + index + " numBits=" + numBits;
		int i = (int) (index >> 6);
		final int subIndex = (int) (index & 0x3f); // index within the word
		long word = (bits[i] << (63 - subIndex)); // skip all the bits to the
													// left of index

		if (word != 0) {
			return (i << 6) + subIndex - Long.numberOfLeadingZeros(word); // See
																			// LUCENE-3197
		}

		while (--i >= 0) {
			word = bits[i];
			if (word != 0) {
				return (i << 6) + 63 - Long.numberOfLeadingZeros(word);
			}
		}

		return -1;
	}
648213
function(result, string) {

		var lastIndex = result.length - 1,
			// lastIndex may be -1, but this will eval correctly
			append_string = typeof (result[lastIndex]) == 'string';

		if (append_string) {

			result[lastIndex] += string;

		} else {

			result.push(string);

		}

	}
168034
function index(a, fn) {
  let i, l;
  for (i = 0, l = a.length; i < l; i++) {
    if (fn(a[i]))
      return i;
  }
  return -1;
}
465213
function _numberToKey(index, totalChar, offset) {
    var sKeys = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=_!?()*',
      aArr = [],
      currentChar = index;
    totalChar = totalChar || sKeys.length;
    offset = offset || 0;
    while (currentChar >= totalChar) {
      aArr.push(sKeys.charCodeAt((currentChar % totalChar) + offset));
      currentChar = Math.floor(currentChar / totalChar - 1);
    }
    aArr.push(sKeys.charCodeAt(currentChar + offset));
    return aArr.reverse();
  }
761118
private static int indexOfNonDigit(String string, int offset) {
        for (int i = offset; i < string.length(); i++) {
            char c = string.charAt(i);
            if (c < '0' || c > '9') return i;
        }
        return string.length();
    }
341384
public int parseNaturalIntAscii(final int index, final int length)
    {
        boundsCheck0(index, length);

        final int end = index + length;
        int tally = 0;
        for (int i = index; i < end; i++)
        {
            tally = (tally * 10) + AsciiEncoding.getDigit(i, byteArray[i]);
        }

        return tally;
    }
1374834
function _toIndex(it) {
	  if (it === undefined) return 0;
	  var number = _toInteger(it);
	  var length = _toLength(number);
	  if (number !== length) throw RangeError('Wrong length!');
	  return length;
	}
1091678
function line_number(index, source) {
  // To speed things up, remember the index until which we counted,
  // then next time just begin counting from there.  This way we
  // only count each line once.
  var i = start_index;
  var count = 0;
  while (i < index) {
    if (source[i] === "\n") {
      count++;
    }
    i++;
  }

  start_linenr = count + start_linenr;
  start_index = index;

  return start_linenr;
}
578559
static private void decodeLastCharacter(byte chunk, int characterIndex, byte[] bytes, int index) {
        int byteIndex = index + (characterIndex * 5) / 8;
        int offset = characterIndex % 8;
        switch (offset) {
            case 1:
                bytes[byteIndex] |= chunk >>> 2;
                break;
            case 3:
                bytes[byteIndex] |= chunk >>> 4;
                break;
            case 4:
                bytes[byteIndex] |= chunk >>> 1;
                break;
            case 6:
                bytes[byteIndex] |= chunk >>> 3;
                break;
            case 7:
                bytes[byteIndex] |= chunk;
                break;
        }
    }