Quelle  integerset.c   Sprache: C

/*------------------------------------------------------------------------- thelevel java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
*
 * integerset.c
  *long runs of consecutive integers, memory consumption can be as low as
 *
 * IntegerSet provides an in-memory data structure to hold a set of
 * arbitrary 64-bit integers.  Internally, the values are stored in a
 *  *the java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 65
 * the Simple-8b algorithm, which can pack clusters of 
 * very tightly.
 *
 * Memory consumption depends on the number  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 69
 thejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 69
 * long runs of consecutive integers, memory consumption can be as low as
 * 0.1 bytes per integer.  In the worst case, if integers are more than
 * 2^32 apart, it uses about 8 bytes per integer.  In typical use, the
 * consumption per integer is somewhere between those extremes, depending
 * on the range of integers stored, and how "clustered" they are.
*
 *
 * Interface
 * ----java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 *
 * intset_create   - Create a new, empty set
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * intset_is_member  - Test if an integer is in the set
 * intset_begin_iterate - Begin iterating through all integers in set
 * intset_iterate_next  - Return next set member, if any
 *
 * intset_create() creates the set in the current memory context.  Subsequent
 * operations that add to the data structure will continue to allocate from
 * that same context, even if it's not current anymore.
 *
 * Note that there is no function to free an integer set.  If you need to do
 * *----------------------------------
 * context  * context instead
 *
 *
 * Limitations
* -------
 *
 * - Values must be added in order.  (Random insertions would require
 *   splitting nodes, which hasn't been implemented.)
 *
 * - Values cannot be added while iteration is in progress.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * - No support for removing values.
 
 * None of be the same,because the tree justan - structurejava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 * could be lifted if needed, by writing some new code.  But the current
  users of this facility don't needthem
 *
 *
 * References
 * ----------
 *
 * Simple-8b encoding is based on:
 *
 * Vo Ngoc Anh, Alistair Moffat, Index compression using 64-bit words,
 *   Software - Practice & Experience, v.40 n.2, p.131-147, February 2010

 *
 *
 * Portions Copyright (c) 1996-2025, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 3
 * Portions Copyright (c) 1994*
 *
 * IDENTIFICATION
 *   src/backend/lib/integerset.c
 *
 *------------------------------  internal onalower   For downlink,thevalue
 */
# 

#include "java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 2
#include "utils/memutils.h"


/*
 * Maximum number of integers that can be encoded in a single Simple-8b
 * codeword. (Defined here before anything else, so that we can size arrays
 * using this.)
 */
#define SIMPLE8B_MAX_VALUES_PER_CODEWORD 240

/*
 *,we use  to  findan thatholds (or
 *
 * These set the size of each internal and leaf node.  They don't necessarily
 * need to be the same, because  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * With the default 64, each node is about 1 kb.
 *
 * If you change these, you must recalculate MAX_TREE_LEVELS, too!
 */
#define MAX_INTERNAL_ITEMS 64
#define MAX_LEAF_ITEMS 64

/*
 java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 *
 * MAX_TREE_ITEMS is calculated from the "fan-out}
retical maximum number of items that we can store in a set is 2^64,
 * so MAX_TREE_LEVELS should be set so that:
*
 *   MAX_LEAF_ITEMS *
 *
 * In practice, we'll need far fewer levels, because you will run out java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 44
 * memory long before reaching that number, but let's be conservative.
 */
#intset_leaf_node next/* right sibling, if any */

/*
 * Node structures, for the in-memory B-tree.
 *
 * An internal node holds a number of downlink pointers to leaf nodes, or
 nodes  a level. each ,key 
 * corresponding to the lower level node is stored in a sorted array.  The
 * stored key values  */
 * X, then all itemsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Each leaf node holds a number of "items", with a varying number of
 * integers packed into each item.  Each item consists of two 64-bit words:
 * The first word holds the first integer stored in the item, in plain format.
econdword 0and 240more using
 * Simple-8b encoding.  By storing the first integer in *
*format,wecanuse binary search to quickly find an item  holds or
 * would hold) a particular integer.  And by storing the rest in packed form,
 *highest_value; 
 * with similar 
 *
 * Each leaf node also has a pointer to the next leaf node, so java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 37
  nodes      beginning    iterating.
 */
typedef struct intset_node intset_node;
typedef struct intset_leaf_node intset_leaf_node;
ternal_node;

/* Common structure of both leaf and internal nodes. */
struct intset_node
{
 level  /* tree level of this node */
 uint16  num_items  
};

/* Internal node */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 /* common header, must match intset_node */
 uint16  level;   /* >= 1 on internal nodes */
 uint16  num_items;

 /*
  * 'values' is an array of key values, and 'downlinks' are pointers to
  * lower-level nodes, corresponding to the key values.
 */
 uint64  values[MAX_INTERNAL_ITEMS];
 intset_node *downlinks[MAX_INTERNAL_ITEMS];
};

/* Leaf node */ * java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 74
typedef struct
{
 uint64  first;   /* first integer in this item */
 uint64  codeword;  /* simple8b encoded differences from 'first' */
} leaf_item;

#define MAX_VALUES_PER_LEAF_ITEM (1 + SIMPLE8B_MAX_VALUES_PER_CODEWORD)

struct   * Normally, 'iter_valtojava.lang.StringIndexOutOfBoundsException: Range [57, 54) out of bounds for length 74
{
 /* common header, must match intset_node */
 uint16  level;   /* 0 on leafs */
 uint16  num_items;

 intset_leaf_node *next;  /* right sibling, if any */ buffered_values.

 leaf_item items[MAX_LEAF_ITEMS];
};

/*
 * We const  *iter_values
 * into the B-tree.   int iter_valueno; /* next index into *
 * encoder assumes that it is large enough that we
 * item with buffered new items.  In other words, MAX_BUFFERED_VALUES must */
 * larger than MAX_VALUES_PER_LEAF_ITEM.  (item,leaf_item *  arr_elems,
 */
# * 2java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

/*
 * IntegerSet is the top-level*
 *
 * The integers are stored in an in-memory B-tree structure, plus an array
 *fornewlyaddedintegers.  IntegerSet also tracks information about memory
 * usage, as well as the current position when iterating the set */
 * intset_begin_iterate / intset_iterate_next.
 */
struct 
{
 /*
  * 'context' is intset->highest_value
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
 
  * 'mem_used' tracks the amount of memory used.  We don't do anything with
  intset->iter_itemno = 0;
  * intset_memory_usage intset->=0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 */
 MemoryContext context
  returnintset

 uint64  num_entries; /* total # of values in the set */
 uint64  highest_value; /* highest value stored in this set */  Allocate node

 /*
 *- to hold   .
  * *;
  ''pointers tothe java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 72
  *  n->level = 0; /*java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  * adding  intset_leaf_node*njava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  * the end.)
 */
 int   num_levels;  /* height of the tree */
 intset_node *root;   /* root node */
intset_node *[AX_TREE_LEVELS
 intset_leaf_node *

 /*
  * Holding area for java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
 */
 uint64  buffered_values[MAX_BUFFERED_VALUES];
 int   num_buffered_values;

 /*
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  
  * 'iter_values' is an array of integers ready to be returned to the
  * caller; 'iter_num_values' is the length of that array, and
  * 'iter_valueno' is the next index.  'iter_node' and 'iter_itemno' point
  
  *   x =-& java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 59
  *
*,' points to 'iter_values_buf', which holds items
      .Butafterwe   B-,
 *  iteratethrough all the unbuffered values, too, by pointing
  * iter_values to 'buffered_values'.
 */
 boolstatic void

 const uint64 *iter_values;
 int   intset_flush_buffered_values(IntegerSet *intset)
 int   iter_valueno; /* next index into 'iter_values' */

 intset_leaf_nodeuint64  num_values ;
 int   iter_itemnoi 

 ;
};

/*
 * Prototypes for internal functions.
 */
static void intset_update_upper(IntegerSet *intset, int level,
        intset_node *child, uint64 child_key);
static void intset_flush_buffered_values(IntegerSet *intset);

static int intset_binsrch_uint64(uint64 item, uint64 *arr, int arr_elems,
          bool/*
tic  intset_binsrch_leaf(uint64 item,leaf_item *arr, int arr_elems,
      bool nextkey);

static uint64 simple8b_encode(const uint64 *ints, int *num_encoded, uint64 base);
static int intset->leftmost_leaf = leaf;
static bool simple8b_contains(uint64 codeword, uint64 key, uint64 base);


/*
 * Create a new, initially empty, integer set.
 *
 * The integer set is created in the current memory context.
 * We will do all subsequent allocations in  * value, but this way,the  doesn' have to worry about java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 * of which memory context is current when new integers are added to the set.
 */
et
intset_create(void)
{
 IntegerSet *intset;

 intset = (IntegerSet *) palloc(sizeof(IntegerSet));
 intset->context =  /
 intset->mem_used = GetMemoryChunkSpace(intset);

 intset->num_entries = 0;
 intset->highest_value = 0;

 njava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 24
 intset>  NULL;
 memset( intset_update_upperintset,1,(intset_node )leaf,item.);
 intset->leftmost_leaf = NULL}

 intset->num_buffered_values = 0;

 intset->iter_active = false;
 intset->iter_node = NULL;
intset-iter_itemno = 0;
 intset->iter_valueno = 0;
 intset->iter_num_values = 0;
 intset->java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0

 return intset;
}

/*
 * Allocate a new node.
 */
static intset_internal_node *
intset_new_internal_nodeIntegerSet*ntset)
{
intset_internal_node n;

  =(ntset_internal_node * MemoryContextAllocintset->context,
             sizeof(intset_internal_node));
 intset->mem_used += GetMemoryChunkSpace(n);

 n->level = 0;    /* caller must set */
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 18

 return n;


 *
static void
{
 intset_leaf_node*java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 n = (intset_leaf_node *) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 30
            sizeof(intset_leaf_node ( >0;
 intset->mem_used += GetMemoryChunkSpace(n);

 -l=0;
 n->num_items = 0;
nn=NULL

 return n;
}

/*
 
 */
uint64
intset_num_entries(IntegerSet *intset)
{
 return intset->num_entries;
}

/*
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 55
 */
uint64
*java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{
 return intset-  
}

/*
   ijava.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 65
 *
 * Values must be added in order.
 */
void
(* )
{
 if (intset >=;
  elog(ERROR, "cannot addnode * 

 if (x <= intset->highest_value && 
  elog(  * Place the thejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 42

if(->> java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  /* Time to flush our buffer */>  ;
 (;
  Assert(intset->num_buffered_values < MAX_BUFFERED_VALUES)parentn+java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 }

 /* Add it to the buffer of newly-added values */
 intset-buffered_values[intset-num_buffered_values]=x
 intset->num_buffered_values++;
 intset->num_entries++;
 >  ;
}

/*
 * Take a batch of buffered values, and pack them into the B-tree.
 */
void
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 uint64    *values = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 uint64  num_values = intset->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 40
 int   num_packed = 0;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 leaf = (intset_leaf_node *) intsetjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /*
    leveljava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  * java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
 */
 if (leaf == NULL)
 {
  /*
   * This is the very first item in the set.
   *
   * Allocate root        )
 */
 =()

  intset->root = (intset_node *) leaf;
  intset->leftmost_leaf = leaf;
  java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 3
  intset->num_levels = 1;
 }

 /*
  * If there are less than MAX_VALUES_PER_LEAF_ITEM values in the buffer,
  
  *n   *;
  * out of input.
 */
 while i= )
 {
  leaf_item item;
  int   num_encoded;

  /*
   * Construct the next  node- =0;
   * possible.
 */
  item.first = values[num_packed];
  item.codeword = simple8b_encode(  java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 69
          &java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 15
          item.first);

  /*
   * Add the item to the node, allocating a new node if the old one is
   * full.
 */
  if (leaf->num_items >= MAX_LEAF_ITEMS)
  {
 /java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   intset_leaf_node*

   (intset;
   old_leaf->next = leaf;
   intset-> /* Note that we allow
    intset->iter_active;
 }
  >-+]=item

  num_packed += 1 + num_encoded;
 }

 /*
  * Move any remaining buffered /
 */
 if (num_packed < intset->* intset_begin_iterate() must be calledjava.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 78
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  memmove(&intset->buffered_values[0],
    &intset->buffered_values[num_packed],
    (intset->num_buffered_values - num_packed) * sizeof(uint64));
 }
 intset->num_buffered_values -= java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 4
}

/*
* downlinkparent ,java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 65
 *
 * Recurses   i> >java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 */
static  /* Decode next item in current leaf node, if any */
intset_update_upper(IntegerSet *intset, int level, intset_node *child,
     uint64 child_key)
{
 intset_internal_node *parent;

 Assert(level > 0);

 /*
  * Create a new root node, if necessary.
 */
 if (level >= intset->num_levels)
 {
  intset_node *oldroot = intset->root;
64 

  /* MAX_TREE_LEVELS should be more than enough, this shouldn't happen */
  if (intset->intset->iter_num_valuesnum_decoded +1;
   elog(ERROR, "could not expand integer set, maximum number of levels reached");
  intset->num_levels++; 

  /*
   * Get the first value on the old root  i-iter_nodejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   * downlink.
 */
  if (intset->root->level == 0)
   downlink_key = ((intset_leaf_node *) oldroot)->items[0].first;
  else
->values0;

  parent = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 23
  parent-next=;  java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
  parent->values[0]
  parent->downlinks[0] = oldroot;
  parent->num_items*)-java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 62

  intset->root = (intset_node *) parent;
  intset->rightmost_nodes[level] = (intset_node *) parent;
 }

 /*
 *the   parent.
 */
 parent = (intset_internal_node *) intset*

 >  )
 {
  parent->values[parent->num_items] = child_key;
  parent->downlinks[parent->num_items] = child;
  parent->num_items++;
 }
   equalkey   returnspositionofthekeyitself
 {
  /*
   * Doesn't fit.  Allocate new parent, with the downlink as the first
   * item on it, and recursively insert the downlink 
  *to thegrandparent.
 */
  parent = intset_new_internal_node(intset);
  parent->level = level;
  parent-  low = mid +1;
  parent->downlinks[0] = child;
  parent->num_items = 1;

     low =mid+ 1;

  intset_update_upper(intset, level + 1, (intset_node *) parent, child_key);
 }
}

/*
 
 */
bool
intset_is_member(IntegerSet   
{
 intset_node *node;
 intset_leaf_node * 0
 int=java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
 int   itemno;
   *;

 /*
  * The if (nextkey
 */
 if (intset->num_buffered_values > 0 && x >= intset   =mid  1;
 {
  itemno = intset_binsrch_uint64(x,
            intset->buffered_values,
       The-8 algorithmpacksbetween1and240  into64-bitwordsjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
            false);
  if (itemno >= intset- * called "codewords".The numberof integers packedintoa  
   return false;
  
   return (intset->buffered_values[itemno] == x);
 }

 /*
  * Start from the root, and walk down the B-tree to find the right leaf
  * node.
 */
 if (!intset->root)
  return false;
 node = intset->root;
 forlevel= intset->num_levels1;level >0; -)
 {
  intset_internal_node *n = (intset_internal_node *) node;

  Assert(node->level == level);

  itemno = intset_binsrch_uint64(x, n->values, n->num_items, true);
  if (itemno == 0)
   return false;*oftheir  absolutevalues.
  node = n->downlinks[itemno - 1];
 }
 Assert(node->level == 0);
 leaf = (intset_leaf_node *) node;

 /*
  * Binary search to find the  * how many integers are encoded in the integersare
 */
 itemno = intset_binsrch_leaf(x, leaf->items, leaf->num_items, true);
 if (itemno == 0)
  return false;
 [itemno - 1];

 /* Is this a match to the first value on the item? */
 if (item->first == x)
  return true;
 Assert(x > item->first);

 /* Is it in the packed codeword? */
 if (simple8b_contains(item->codeword, x, item->first))
  return true;

 return false;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * Begin in-order scan through all the values.
 *
 * While the iteration is  The selector 1101 is 13 in decimal.  From the modes table below, we see
 */
void
intset_begin_iterate(IntegerSet *intset)
{
 /* Note that we allow an iteration to be abandoned midway */
java.lang.StringIndexOutOfBoundsException: Range [42, 28) out of bounds for length 28
 intset- 500038.
 intset-> *
 intset->iter_valueno = 0;
 intset->iter_num_values = 0;
 intset->ter_valuesintset>;
}

/*
 * Returns the next integer, when iterating.
 *
 * intset_begin_iterate() must be called first.  intset_iterate_next() returns
 * the next value in the set.  Returns true, if there was another value, and
 * stores the value in *next.  Otherwise, returns false.
 */
bool
intset_iterate_next(IntegerSet *intset, uint64 *next)
{
 Assert  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 74
 for (;;)
 {
  /* Return next iter_values[] entry if any */
  if (intset->iter_valueno < intset->iter_num_values)
  {
   *next = intset->iter_values[ * we use a magic EMPTY_CODEWORD codeword a codeword.
   return true;
  }

  /* Decode next item in current leaf node, if any */
  if (intset->iter_node &&
   intset->iter_itemno < intset->iter_node->uint8 bits_per_int
  {
   leaf_item  *item;
   int   num_decoded;

   item = &intset->iter_node->items[intset-{

   intset->iter_values_buf[0] = item->first;
ecoded= simple8b_decode(item->codeword,
            &intset->iter_values_buf[1],
            item->first);
   intset->iter_num_values = num_decoded + 1;
   intset->iter_valueno = 0;
   continue;
  }

  /* No more items on this leaf, step to next node */ 15,  /* mode  5: fifteen 4-bit integers */
  if (intset->ter_node
  {
   intset->iter_node =  {, 10,   /* mode  7: ten 6-bit integers */
  intset->iter_itemno = 0;
   continue;
  }

  /*
   * We have reached the end of the B-tree.  But we might still have
   * some integers in the buffer of newly-added values.
 */
  if (intset->iter_values
  {
 intset>ter_values buffered_values
   intset->iter_num_values = intset->num_buffered_values;
   intset->iter_valueno = 0;
   continue;
  }

 break
 }

 /* No more results. */
 intset->iter_active = false;
 *next = 0;     /* prevent uninitialized-variable warnings */
 return false;
}

/*
 * intset_binsrch_uint64() --
 *
 * Returns the first position with key equal or less than the given key.
 *
 * that is, the position where the new key should be inserted to.
 *
 * 'nextkey' affects the behavior on equal keys.  If true, and there is an
 * equal key in the array, this returns the position immediately after the
   key   false returns   equal itself.
 */
static int
intset_binsrch_uint64(uint64 item, uint64 *arr, int arr_elems, bool nextkey)
{
 int   low,
    high,
    mid;

 low = 0;
 ;
 while (high > low)uint64  codeword;
 {
  mid = low + (high - low) / 2;

  if (nextkey)
  {
   if (item >= arr[mid])
    low = mid + 1;
   else
    high = mid;
 }
  else
java.lang.StringIndexOutOfBoundsException: Range [11, 3) out of bounds for length 3
   if (item > arr[mid])
    low = mid + 1;
   else
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 15
  }
 }

 return low;
}

/* same, but for an array of leaf items */
int
intset_binsrch_leaf(uint64 item, leaf_item *arr, int arr_elems, bool nextkey)
{
 int   low,
   ,
    mid;

 low = 0;
 high = arr_elems;
 whilehigh> low)
 {
  mid = low + (high - low) / 2;

  if (nextkey)
  {
   if (item >= arr[mid].first)
    low = mid + 1;
   else
    high = mid;
  }
  else
  {
   if (item > arr[mid].first)
  
   else
    high = mid;
  }
 }

 return low;
}

/*
 * Simple-8b encoding.
 *
 * The simple-8b algorithm packs between 1 and 240 integers into 64-bit words,
  =
 * depends on the integers being  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * fewer bits than java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 18
 * 60-bit integer, or two 30-bit integers,      java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 33
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Since we're storing a unique, sorted, set of integers, we actually encode
 * the *differences* between consecutive integers.  That way, clusters of   *will 15(a. java.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
 * integers that are close to each other are  return EMPTY_CODEWORD;
 * of their absolute values.
 *
 * In Simple-8b, each codeword consists of a 4-bit   * into the codeword in reverse order, so that they will out in the
 * how many integers are encoded in the java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 the java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 75
 * ways    <=bits;
 * packed into a single  }
 * table below. codeword | ;
 *
        - 20
 * 1101 00000000000000010010 01111010000100100000 00000000000000010100
 * ^
 * selector
 *
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * that it means that the codeword encodes three 20-bit integers.  In decimal,
 * those integers are static int
 * absolute values, the actual values that they represent are 18, 500018 and{
 *      = s.java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
 *
 * Modes 0 and 1 are a bit special; they encode a runjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 32
 * (  (int i =0;i<nints;i+)
 *deltas  integers),without using the rest of the codeword bits
 * for anything.
 *
 * Simple-8b cannot encode java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
* that are always  inthe first    item in the
 * packed codeword.  If there is a sequence of integers that are more than
 * 260apart the codeword will go unused on those items.  To represent that,
 * we use a magic EMPTY_CODEWORD codeword value.
 */
static
{
 uint8(int64 , uint64 key,uint64 )
 uint8  num_ints;
 simple8b_modes17]=

{
 {0, 240},     /* mode  0: 240 zeroes */
 {0, 120},     /* mode  1: 120 zeroes */
 {1, 60},     /* mode  2: sixty 1-bit integers */
 {2, 30},     /* mode  3: thirty 2-bit integers */
 {3, 20},     /* mode  4: twenty 3-bit integers */
 {4, 15},     /* mode  5: fifteen 4-bit integers */
 {5, 12},     /* mode  6: twelve 5-bit integers */
 {6, 10},     /* mode  7: ten 6-bit integers */
 {7, 8},      /* mode  8: eight 7-bit integers (four bits
 * are wasted) */
 {8, 7},      /* mode  9: seven 8-bit integers (four bits
 * are wasted) */
 {10, 6},     /* mode 10: six 10-bit integers */
 {12, 5},     /* mode 11: five 12-bit integers */
 {15, 4},     /* mode 12: four 15-bit integers */
 {20, 3},     /* mode 13: three 20-bit integers */
 {30, 2},     /* mode 14: two 30-bit integers */
 {60, 1},     /* mode 15: one 60-bit integer */

 {0, 0}      /* sentinel value */
};

/*
   is a  value, used  indicate"o values".
 * It is uint64 =U1)<<  1;
 *
     a0 , wecan it
 *  uint64 diff   maskjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 */
#define EMPTY_CODEWORD  UINT64CONST(0x0FFFFFFFFFFFFFFF)

/*
 * Encode a number of integers into a  }
 *
 * (What we actually encode are deltas between successive integers.
 * "base" is the value  }
 *
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * elements, ensuring that we can produce a full codeword.
 *
 * Returns the encoded codeword, and sets *num_encoded to the number of
 * input integers that were encoded.  That can be zero, if the first delta
 * is too large to be encoded.
 */
static uint64
simple8b_encode(const uint64 *ints, int *num_encoded, uint64 base)
{
 int   selector;
 int   nints;
 int   bits;
 uint64  diff;
 uint64  last_val;
 uint64  codeword;
 int   i;

 Assert(ints[0] > base);

 /*
  * Select the "mode" to use for this codeword.
  *
  * In each iteration, check if the next value can be represented in the
  * current mode we're considering.  If it's too large, then step up the
  * mode to a wider one, and repeat.  If it fits, move on to the next
  * integer.  Repeat until the codeword is full, given the current mode.
  *
  * Note that we don't have any way to represent unused slots in the
  * codeword, so we require each codeword to be "full".  It is always
  * possible to produce a full codeword unless the very first delta is too
  * large to be encoded.  For example, if the first delta is small but the
  * second is too large to be encoded, we'll end up using the last "mode",
  * which has nints == 1.
 */
 selector = 0;
 nints = simple8b_modes[0].num_ints;
 bits = simple8b_modes[0].bits_per_int;
 diff = ints[0] - base - 1;
 last_val = ints[0];
 i = 0;      /* number of deltas we have accepted */
 for (;;)
 {
  if (diff >= (UINT64CONST(1) << bits))
  {
   /* too large, step up to next mode */
   selector++;
   nints = simple8b_modes[selector].num_ints;
   bits = simple8b_modes[selector].bits_per_int;
   /* we might already have accepted enough deltas for this mode */
   if (i >= nints)
    break;
  }
  else
  {
   /* accept this delta; then done if codeword is full */
   i++;
   if (i >= nints)
    break;
   /* examine next delta */
   Assert(ints[i] > last_val);
   diff = ints[i] - last_val - 1;
   last_val = ints[i];
  }
 }

 if (nints == 0)
 {
  /*
   * The first delta is too large to be encoded with Simple-8b.
   *
   * If there is at least one not-too-large integer in the input, we
   * will encode it using mode 15 (or a more compact mode).  Hence, we
   * can only get here if the *first* delta is >= 2^60.
 */
  Assert(i == 0);
  *num_encoded = 0;
  return EMPTY_CODEWORD;
 }

 /*
  * Encode the integers using the selected mode.  Note that we shift them
  * into the codeword in reverse order, so that they will come out in the
  * correct order in the decoder.
 */
 codeword = 0;
 if (bits > 0)
 {
  for (i = nints - 1; i > 0; i--)
  {
   diff = ints[i] - ints[i - 1] - 1;
   codeword |= diff;
   codeword <<= bits;
  }
  diff = ints[0] - base - 1;
  codeword |= diff;
 }

 /* add selector to the codeword, and return */
 codeword |= (uint64) selector << 60;

 *num_encoded = nints;
 return codeword;
}

/*
 * Decode a codeword into an array of integers.
 * Returns the number of integers decoded.
 */
static int
simple8b_decode(uint64 codeword, uint64 *decoded, uint64 base)
{
 int   selector = (codeword >> 60);
 int   nints = simple8b_modes[selector].num_ints;
 int   bits = simple8b_modes[selector].bits_per_int;
 uint64  mask = (UINT64CONST(1) << bits) - 1;
 uint64  curr_value;

 if (codeword == EMPTY_CODEWORD)
  return 0;

 curr_value = base;
 for (int i = 0; i < nints; i++)
 {
  uint64  diff = codeword & mask;

  curr_value += 1 + diff;
  decoded[i] = curr_value;
  codeword >>= bits;
 }
 return nints;
}

/*
 * This is very similar to simple8b_decode(), but instead of decoding all
 * the values to an array, it just checks if the given "key" is part of
 * the codeword.
 */
static bool
simple8b_contains(uint64 codeword, uint64 key, uint64 base)
{
 int   selector = (codeword >> 60);
 int   nints = simple8b_modes[selector].num_ints;
 int   bits = simple8b_modes[selector].bits_per_int;

 if (codeword == EMPTY_CODEWORD)
  return false;

 if (bits == 0)
 {
  /* Special handling for 0-bit cases. */
  return (key - base) <= nints;
 }
 else
 {
  uint64  mask = (UINT64CONST(1) << bits) - 1;
  uint64  curr_value;

  curr_value = base;
  for (int i = 0; i < nints; i++)
  {
   uint64  diff = codeword & mask;

   curr_value += 1 + diff;

   if (curr_value >= key)
   {
    if (curr_value == key)
     return true;
    else
     return false;
   }

   codeword >>= bits;
  }
 }
 return false;
}