The end key position is in this record... Save it!
3857
public void handleEndKey()
    {
        KeyArea keyArea = this.getKeyArea(-1);
        if (keyArea == null)
            return;
        BaseBuffer buffer = new VectorBuffer(null);
        boolean[] rgbModified = keyArea.getModified();
        boolean[] rgbNullable = keyArea.setNullable(true);
        keyArea.setupKeyBuffer(buffer, DBConstants.FILE_KEY_AREA);
        keyArea.zeroKeyFields(DBConstants.END_SELECT_KEY);      // Set the key fields to a large value
        BaseListener  nextListener = this.getNextEnabledListener();
        if (nextListener != null)
            ((FileListener)nextListener).doEndKey();
        else
            this.doEndKey();
        keyArea.setNullable(rgbNullable);
        keyArea.setModified(rgbModified);
        keyArea.reverseKeyBuffer(buffer, DBConstants.FILE_KEY_AREA);
    }
1105380
def position_at_end(self, block):
        
        self._block = block
        self._anchor = len(block.instructions)
1261443
public boolean isEOF()
    {
        boolean bFlag = ((m_iRecordStatus & DBConstants.RECORD_AT_EOF) != 0);
        if (this.isTable())
        {   // If this is a table, it can't handle starting and ending keys.. do it manually
            if (bFlag)
                return bFlag;
            if (this.getRecord().getKeyArea(-1).isModified(DBConstants.END_SELECT_KEY))
            {
                if (!bFlag)
                    bFlag = this.getRecord().checkParams(DBConstants.END_SELECT_KEY);
                if (bFlag)
                    m_iRecordStatus |= DBConstants.RECORD_AT_EOF; // At EOF
            }
        }
        return bFlag;
    }
130883
public void restorePosition() {
		RecordId rid1 = savedPosition.get(0);
		RecordId rid2 = savedPosition.get(1);
		s1.moveToRecordId(rid1);
		if (rid2 != null)
			s2.moveToRecordId(rid2);
	}
98249
function _storeEof()
	{
		$record    = 0x000A;   // Record identifier
		$length    = 0x0000;   // Number of bytes to follow

		$header    = pack("vv", $record, $length);
		$this->_append($header);
	}
1241419
public void insertKVRecord(Object keyBase, long keyOffset, int keyLen,
      Object valueBase, long valueOffset, int valueLen, long prefix, boolean prefixIsNull)
    throws IOException {

    growPointerArrayIfNecessary();
    int uaoSize = UnsafeAlignedOffset.getUaoSize();
    final int required = keyLen + valueLen + (2 * uaoSize);
    acquireNewPageIfNecessary(required);

    final Object base = currentPage.getBaseObject();
    final long recordAddress = taskMemoryManager.encodePageNumberAndOffset(currentPage, pageCursor);
    UnsafeAlignedOffset.putSize(base, pageCursor, keyLen + valueLen + uaoSize);
    pageCursor += uaoSize;
    UnsafeAlignedOffset.putSize(base, pageCursor, keyLen);
    pageCursor += uaoSize;
    Platform.copyMemory(keyBase, keyOffset, base, pageCursor, keyLen);
    pageCursor += keyLen;
    Platform.copyMemory(valueBase, valueOffset, base, pageCursor, valueLen);
    pageCursor += valueLen;

    assert(inMemSorter != null);
    inMemSorter.insertRecord(recordAddress, prefix, prefixIsNull);
  }
1106569
def record_little_endian(self):
        # type: () -> bytes
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('Path Table Record not yet initialized')

        return self._record(self.extent_location, self.parent_directory_num)
654772
function nextRaw()
    {
        if ($this->type == self::SOURCE_FILE) {
            $record = stream_get_line($this->source, File_MARC::MAX_RECORD_LENGTH, File_MARC::END_OF_RECORD);

            // Remove illegal stuff that sometimes occurs between records
            $record = preg_replace('/^[\\x0a\\x0d\\x00]+/', "", $record);

        } elseif ($this->type == self::SOURCE_STRING) {
            $record = array_shift($this->source);
        }

        // Exit if we are at the end of the file
        if (!$record) {
            return false;
        }

        // Append the end of record we lost during stream_get_line() or explode()
        $record .= File_MARC::END_OF_RECORD;
        return $record;
    }
957108
def endElement(self, name, value, connection):
        """"""
        if name == 'NextRecordName':
            self.next_record_name = value
        elif name == 'NextRecordType':
            self.next_record_type = value
        else:
            return ResultSet.endElement(self, name, value, connection)
167264
public static void putDecimalNormalizedKey(
			Decimal record, MemorySegment target, int offset, int len) {
		assert record.getPrecision() <= Decimal.MAX_COMPACT_PRECISION;
		putLongNormalizedKey(record.toUnscaledLong(), target, offset, len);
	}
1108974
function (evt) {
    var key = evt.keyCode;
    var KEYS = {space: 32};
    switch (key) {
      // <space>: Toggle recording.
      case KEYS.space: {
        this.toggleRecording();
        break;
      }
    }
  }
1243860
def _hole_end(self, position, ignore=None):
        
        for rindex in range(position, self.max_end):
            for starting in self.starting(rindex):
                if not ignore or not ignore(starting):
                    return rindex
        return self.max_end
1351926
def read_to_end(self, record=None):
        

        # no current record to read
        if not self.record:
            return None

        # already at end of this record, don't read until it is consumed
        if self.member_info:
            return None

        curr_offset = self.offset

        while True:
            b = self.record.raw_stream.read(BUFF_SIZE)
            if not b:
                break

        """
        - For compressed files, blank lines are consumed
          since they are part of record length
        - For uncompressed files, blank lines are read later,
          and not included in the record length
        """
        #if self.reader.decompressor:
        self.next_line, empty_size = self._consume_blanklines()

        self.offset = self.fh.tell() - self.reader.rem_length()
        #if self.offset < 0:
        #    raise Exception('Not Gzipped Properly')

        if self.next_line:
            self.offset -= len(self.next_line)

        length = self.offset - curr_offset

        if not self.reader.decompressor:
            length -= empty_size

        self.member_info = (curr_offset, length)
345891
function _storeVcenter()
    {
        $record   = 0x0084;              // Record identifier
        $length   = 0x0002;              // Bytes to follow

        $fVCenter = $this->_vcenter;     // Horizontal centering

        $header    = pack("vv", $record, $length);
        $data      = pack("v",  $fVCenter);
        $this->_prepend($header . $data);
    }
1094243
public function endWrite()
    {
        if (false !== $this->firstHarvestedId) {
            $this->saveFile(
                $this->firstHarvestedId, $this->getCombinedXML($this->innerXML)
            );
        }

        if (!empty($this->deletedIds)) {
            $this->saveDeletedRecords($this->deletedIds);
        }
    }
1258146
def include_end(self):
        
        self.lex = self.filestack[-1][2]
        self.input_data = self.filestack[-1][3]
        self.filestack.pop()

        if not self.filestack:  # End of input?
            return

        self.filestack[-1][1] += 1  # Increment line counter of previous file

        result = lex.LexToken()
        result.value = self.put_current_line(suffix='\n')
        result.type = '_ENDFILE_'
        result.lineno = self.lex.lineno
        result.lexpos = self.lex.lexpos

        return result
81156
def end(self):
        """"""
        for comic in self.data:
            with codecs.open(self.jsonFn(comic), 'w', self.encoding) as f:
                json.dump(self.data[comic], f, indent=2, separators=(',', ': '), sort_keys=True)