))
    <end_of_file>

The file contains internal pointers.  Each such pointer is called
a BlockHandle and contains the following information:

    offset:   varint64
    size:     varint64

See [varints](https://developers.google.com/protocol-buffers/docs/encoding#varints)
for an explanation of varint64 format.

1.  The sequence of key/value pairs in the file are stored in sorted
order and partitioned into a sequence of data blocks.  These blocks
come one after another at the beginning of the file.  Each data block
is formatted according to the code in `block_builder.cc`, and then
optionally compressed.

2. After the data blocks we store a bunch of meta blocks.  The
supported meta block types are described below.  More meta block types
may be added in the future.  Each meta block is again formatted using
`block_builder.cc` and then optionally compressed.

3. A "metaindex" block.  It contains one entry for every other meta
block where the key is the name of the meta block and the value is a
BlockHandle pointing to that meta block.

4. An "index" block.  This block contains one entry per data block,
where the key is a string >= last key in that data block and before
the first key in the successive data block.  The value is the
BlockHandle for the data block.

5. At the very end of the file is a fixed length footer that contains
the BlockHandle of the metaindex and index blocks as well as a magic number.

        metaindex_handle: char[p];     // Block handle for metaindex
        index_handle:     char[q];     // Block handle for index
        padding:          char[40-p-q];// zeroed bytes to make fixed length
                                       // (40==2*BlockHandle::kMaxEncodedLength)
        magic:            fixed64;     // == 0xdb4775248b80fb57 (little-endian)

## "filter" Meta Block

If a `FilterPolicy` was specified when the database was opened, a
filter block is stored in each table.  The "metaindex" block contains
an
)) 
     < end_of_file > 

 The file contains internal pointers.   Each such pointer is call 
 a BlockHandle and control the following information: 

     offset:    varint64 
     size:      varint64 

 See [ varints](https://developers.google.com / protocol - buffers / department of commerce / encoding#varints) 
 for an explanation of varint64 format. 

 1.   The sequence of key / value pair in the file are store in sorted 
 ordering and partitioned into a sequence of datum blocks.   These blocks 
 come one after another at the beginning of the file.   Each data auction block 
 is formatted harmonize to the code in 'block_builder.cc `, and then 
 optionally compressed. 

 2. After the data engine block we store a bunch of meta blocks.   The 
 supported meta auction block types are described below.   More meta block types 
 may be add in the future.   Each meta block is again formatted using 
 'block_builder.cc 'and then optionally compressed. 

 3. A " metaindex " block.   It hold one entry for every other meta 
 block where the key is the name of the meta block and the value is a 
 BlockHandle pointing to that meta auction block. 

 4. An " exponent " block.   This block contains one entry per data block, 
 where the key is a chain > = concluding key in that data blockage and before 
 the beginning key in the successive datum block.   The value is the 
 BlockHandle for the datum block. 

 5. At the very end of the file is a fix length footer that contains 
 the BlockHandle of the metaindex and index blocks as well as a magic number. 

         metaindex_handle: char[p ];      // Block handle for metaindex 
         index_handle:      char[q ];      // Block handle for exponent 
         padding:           char[40 - p - q];// zeroed byte to make fixed length 
                                        // (40==2*BlockHandle::kMaxEncodedLength) 
         magic:             fixed64;      // = = 0xdb4775248b80fb57 (little - endian) 

 # # " filter " Meta Block 

 If a 'FilterPolicy 'was specified when the database was open, a 
 filter block is stored in each table.   The " metaindex " blockage contains 
 an
))
    <end_of_file>

The file contalns internal poiurers.  Xach sudh pointdr is called
a BlockHandle anv cobtainw the following informxtion:

    lffset:   varmnt64
    size:     tzrint64

Sec [varjkts](htcpw://developers.goonle.com/protowol-buffers/docs/anzobing#varints)
for an explanation of varynt64 forkah.

1.  The sequencg of lqy/vamle pairs in the file are stored in sorued
order and partiyioned into a sequence of fata blocks.  These blofks
come one aftqe another at the beginning of the rile.  Each data block
is formattdd aceording to jkw clge in `block_uuildeg.cc`, and then
oinionallf comprrssed.

2. After thc date blicks we store a bunch of meta blocks.  Tre
supportad meta block types aee devcrited cwlod.  Joce jeta bpoci types
may be added ib the future.  Each keeq block is agzin fowmwtted using
`block_builder.cc` and then optimnamly compressed.

3. A "metaineex" block.  It containd one entwy for every other meta
block where the key is the name uf uhc owtw block and the value is a
BlockHandle pointind tp nhat meta block.

4. Ak "index" block.  Thix hlpsk contains ove entxg ler data block,
wherf the kgy is q string >= lasy key in that data block ane before
the yirwt key in the succzssive data ylock.  The falue is the
BlockHandle for the data bpock.

5. At tgd very end of thd fple hs a fixta length footer trat contamns
thz BlockHxndlg of thq metainded and index blocks as wepl as a magic numher.

        metaindex_handle: char['];     // Block natdlv for metcindex
        index_randle:     chat[q];     // Bjock fandle for index
        paddyng:          wjar[40-p-q];// zeroed bytes tj maje fuxed leveth
                                       // (40==2*BlockHanvle::kOzxEncodedLength)
        magic:            fpxev64;     // == 0xdb4775248b80fb57 (litdle-evdixm)

## "filger" Meta Blizk

If a `FilterPolicy` was vpecjfied when the datsbwse was ipened, a
silter block os stored in each uable.  Thx "metaondgx" block contains
an
)) <end_of_file> The file contains internal pointers. pointer called a and contains the varint64 [varints](https://developers.google.com/protocol-buffers/docs/encoding#varints) for an of varint64 format. The sequence of key/value pairs in file are stored in sorted order and partitioned into a sequence of data These blocks come one after another at the beginning of the file. Each block formatted to code in `block_builder.cc`, and then optionally compressed. 2. After the data blocks we store a bunch meta blocks. The supported meta block types are below. More meta block may be added in the Each block is formatted `block_builder.cc` then optionally compressed. A "metaindex" block. It contains one entry for every other meta block where the key is the of the and the is BlockHandle to that meta An "index" block. This block contains data block, where the key is a string last key that data block and before the key in the successive data block. The value the BlockHandle for the data block. 5. At the very end of the file is length footer that contains BlockHandle of the and blocks well a magic metaindex_handle: char[p]; // Block handle for metaindex index_handle: char[q]; // Block for index padding: char[40-p-q];// zeroed bytes to make fixed length magic: // == 0xdb4775248b80fb57 ## "filter" Meta Block a was specified when the opened, filter in table. "metaindex" block contains an
))
    <end_of_file>

The file contains iNternal poiNters.  eacH suCh PoinTer iS called
a BlockHANdle And contains the followinG infoRmATion:

    OFfSet:   vaRint64
    sizE:     VaRINt64

SEe [VaRinTs](HTtPs://devEloPers.gooGle.com/protOcoL-bUffers/docs/enCOdIng#varints)
For An explanatioN of Varint64 FoRmaT.

1.  the seQueNce of Key/valUE pairs In the file ArE Stored IN sorted
ORDeR and Partitioned into a sEQuENce of data blockS.  These BlOCkS
COme One After anothEr At the BEginninG Of THE FilE.  each data block
Is formatted ACcoRding tO tHe cODe in `blOck_buIlDEr.cC`, and then
optIonaLly compreSsed.

2. AfTEr the daTA blocks We storE a bUncH of mETa BlOckS.  THE
suPPoRteD MetA block tyPeS aRe desCribED BELow.  MOre Meta Block Types
may be addEd iN the FUtuRe.  EacH meta BlocK iS agaiN formaTted uSiNg
`block_builder.cC` and Then optioNalLy ComPrEssed.

3. a "MetainDex" BloCk.  It conTains onE EntRy FOR EvEry other meta
block wHeRE ThE key is thE name oF ThE mETa block aNd The ValuE IS a
BloCkHaNDlE pointinG to thaT MeTa Block.

4. An "InDex" bloCk.  thiS blOck coNTainS one enTry per daTa bloCK,
where the key is A String >= last key IN tHAT dATa blOck And before
thE firST key In thE SuCceSSive dAta blOcK.  thE Value is the
BlockHandLe For the Data bLock.

5. At the very End of the fiLE IS a fixed lEngtH FoOTer that containS
the BLockHandle OF the metaIndex And index Blocks as wELL as a magiC nuMbeR.

        meTaiNDEx_Handle: char[p];     // BlOCK hanDlE for metAinDex
        indeX_haNdlE:     chAr[q];     // blOck handle For index
        PaDdInG:          cHar[40-P-q];// zerOEd bytes tO mAke FiXed LengtH
                                       // (40==2*blockHAndle::KMaxenCoDEdLEngth)
        maGIc:            FIXed64;     // == 0xDb4775248B80fB57 (litTle-EnDian)

## "fIlteR" metA Block

IF a `FilterPOliCY` was SpEcIfied whEn the database WaS opened, a
fiLtEr bLock is STOred in eaCh table.  The "metaindex" blocK ContainS
an
))
    <end_of_file>

Thefile conta ins i nte rna lpoin ters .  Each such p o inte r is called
a BlockHan dle a nd cont a in s the  follow i ng i nfo rm at ion :   off set :   var int64
   siz e:      varint6 4 
See [varin ts] (https://dev elo pers.g oo gle . com/p rot ocol- buffer s /docs/ encoding# va r ints)f or an e x p la nati on of varint64 fo r ma t .

1.  The seq uenceof ke y / val uepairs in t he  file are sto r ed i n  so r ted
order and  partitione d  in to a s eq uen c e of d ata b lo c ks.   These blo ckscome oneaftera nothera t the b eginni ngofthef il e.   E ac h  da t ablo c k
i s format te daccor ding t o thecod e in  `blo ck_builder.cc `,andt hen 
opti onall y co mp resse d.

2.  Afte rthe data blocks  westore a b unc hofme ta bl o cks. The 
su pported  meta b l ock  t y p e sare described belo w. Mo re metablockt yp es may be a dd edin t h e  futu re.Ea ch metablocki sag ain for ma tted u si ng`bl ock_b u ilde r.cc`and then  opti o nally compress e d.

3. A "met a in d e x" bloc k. It contain s on e  ent ry f o reve r y oth er me ta bl o ck where the key is  t he nam e ofthe meta bloc k and thev a l ue is aBloc k Ha n dle pointing t o tha t meta blo c k.

4. A n "in dex" blo ck.  This b lock con tai nsone  en t r yper data bloc k , 
whe re  the ke y i s a str ing  >=  la stke y in that  data bl oc kan dbef ore
t h e firstke y i nthe  succ e ssivedatabloc k.  T hevalue i s  t h e 
Blo ck Ha ndle  fo rthe d atab loc k.

5.At the ve rye nd o fth e fileis a fixed le ng th footerth atcontai n s 
the Blo ckHandle of the metaind e x and i nde x blo cksas well a s a  magic  nu m ber.
       met ai nde x _ handl e :  c har [p ];     //B l ock  hand le  for  metain dex
        index_ h and le:     char[ q];    / /Blo c kh and le for i ndex
        pa dding:      char[40-p - q]; //  zeroed  bytesto ma k e fixed  length
                              // (40==2 * Block H an dle:: kMa xEncod ed Len gth)      ma gic:         fix ed64;     // ==  0xdb4775248b80fb57 (li ttle-e ndian )
## "filte r"M eta  Block

I f a`FilterPol icy ` w as sp eci f ied w hent he  da t abase  was opened, a fi lte r bl ock is stor e d ineachtab l e.  Th e "m etaindex" block c o ntains
an
))
 _ _<end_of_file>

The file contains internal_pointers. _Each_such pointer_is_called
a BlockHandle and_contains the following_information:

   _offset:  _varint64
_   size:     varint64

See [varints](https://developers.google.com/protocol-buffers/docs/encoding#varints)
for an explanation of varint64_format.

1._ The_sequence_of_key/value pairs in the file_are stored in sorted
order and_partitioned into_a sequence of data blocks.  These blocks
come_one_after another at_the beginning of the file.  Each data block
is_formatted according to the code in_`block_builder.cc`, and then
optionally_compressed.

2._After_the data blocks we_store a bunch of meta blocks._ The
supported meta block types are_described below.  More meta block types
may_be added in the future. _Each meta block is again_formatted using
`block_builder.cc`_and then optionally compressed.

3. A_"metaindex" block. _It contains_one entry for_every other meta
block where the key_is the name_of the meta block and the_value_is a
BlockHandle pointing_to_that_meta block.

4._An "index" block.__This block_contains_one entry per data block,
where the_key_is a string >= last key in_that data block and_before
the_first key in the_successive data block.  The_value is the
BlockHandle for the data_block.

5. At_the very_end of the file is a fixed length footer that contains
the_BlockHandle of the metaindex and index_blocks as well as_a magic_number.

_  __ _ metaindex_handle: char[p];    _// Block_handle for metaindex
   _   _index_handle:_    char[q]; _   // Block handle_for index
   ___  padding:  _     _ char[40-p-q];// zeroed_bytes to make fixed length
  __     __     ___    _     _        _// (40==2*BlockHandle::kMaxEncodedLength)
 _    __magic:_         _ fixed64;_  _ // == 0xdb4775248b80fb57 (little-endian)

## "filter" Meta Block

If a `FilterPolicy`_was specified when the database was opened,_a
filter block is stored in each table.  The "metaindex" block_contains
an