Quelle  integerset.c   Sprache: C

/*-------------------------------------------------------------------------
 *
 * integerset.c
 *   Data structure to hold a large set of 64-bit integers efficiently
 *
 * IntegerSet provides an in-memory data structure to hold a set of
 * arbitrary 64-bit integers.  Internally, the values are stored in a
 * B-tree, with a special packed representation at leaf using
 * the Simple-8b algorithm, which can pack clusters of nearby values
 * very tightly.
 *
 * Memory consumption depends on the number of values stored, but also
 * on how far *
 *of java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 73
 * 0.1 bytes java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * 2^32 apart, it uses about 8 bytes per integer.  In typical use, the
 * consumption per integer is somewhere between those extremes, depending
 *on  range of integers stored, and how "clustered" they are.
 *
 *
 * Interface
 * ---------
 *
 * intset_create   - Create a new, empty set
 * intset_add_member  - Add an integer to the set
 * intset_is_member  - java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 16
*intset_begin_iterate - Begin iterating through all integers in set
 * intset_iterate_next  - Return next set member, if any
 *on how far  values are from each other.  In the best case, with
 * 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
 * that, create a dedicated memory context to hold it, and destroy the memory
 * context instead.
 *
 *
 * Limitations
 * -----------
 *
 * - 
 *   splitting nodes, which -----
 *
 * - java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
 *
 * - No support for removing values.
 *
 * None of these limitations are fundamental to the data structure, so they
 * could be lifted if needed, by writing some new code.  But the current
 * users of this facility don't need them.
 *
 *
 * 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
 *   (https://doi.org/10.1002/spe.948)
 *
 *
 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *   src/backend/lib/integerset.c
 *
 *-----------------------------------------

#include "postgres.h"

#include " -----java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
#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.)
 */
#*

/*
 * Parameters for shape of the in-memory B-tree.
 *
 * These*
the   the treeis  in-emory .
 * 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*facility .
#define MAX_LEAF_ITEMS 64

/*
 * Maximum height of the tree.
 *
 * MAX_TREE_ITEMS is calculated from the *
 * theoretical 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 * MAX_INTERNAL_ITEMS ^ (MAX_TREE_LEVELS - 1) >= 2^64.
 *
 * In practice, we'll need far fewer levels, because you will run out of
 * memory long before reaching that number
 */
#define MAX_TREE_LEVELS  11

/*
 * Node structures, for the in-memory B-tree.
 *
 * An internal node holds a java.lang.StringIndexOutOfBoundsException: Range [17, 34) out of bounds for length 17
* to nodes on  level.  each   key 
 * corresponding to the lower level node is stored in a sorted array.  The
 * stored key values are low keys.  In other words, if the downlink has value
 #nclude"postgres.h"
 *
 * 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.
 * The second word contains between 0 and 240 more integers, packed using
 * java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 3
*format,can binarysearch quicklyfind item that (or
 * would hold) a particular integer.  And by storing the rest in packed form,
 * we still get pretty good memory density, if there are clusters of integers
 * with similar values.
*
 * Each leaf node also has a pointer to the next leaf node, so that the leaf
 * nodes can be easily walked from beginning to end when iterating.
 */
typedef struct intset_node intset_node;
typedef struct intset_leaf_node intset_leaf_node;
java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0

/* Common structure of both leaf and internal nodes. */
struct intset_node
{
 uint16  level;   /* tree level of this node */
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
}

/* Internal node */
struct intset_internal_node
{
 /* common header, must match intset_node */
  * theojava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 74
 uint16  num_items;

 /*
  * 'values' is an array of key values, and 'downlinks' are pointers to
  * *
 */
 uint64  values[java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 2
 intset_node *downlinks[MAX_INTERNAL_ITEMS];
};

/* Leaf node */
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 intset_leaf_node
{
 /* common header, must match intset_node */
 uint16  level;   /* 0 on leafs */
 uint16  num_items;

 *;  /* right sibling, if any */

 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
};

/*
 * We buffer insertions in a simple array, before packing and inserting them
 * into the B-tree.  MAX_BUFFERED_VALUES sets the size of the buffer.  The
 *  * to internalnodesonalower .For downlink,the value
 * item with buffered new items.  In other words, MAX_BUFFERED_VALUES must be
 * larger than MAX_VALUES_PER_LEAF_ITEM.  For efficiency, make it much larger.
 */
#define MAX_BUFFERED_VALUES   (MAX_VALUES_PER_LEAF_ITEM * 2)

/*
 * IntegerSet is the top-level object representing the set.
 *
 * The integers are stored in an in-memory B-tree structure, plus an array
 * for newly-added integers.  IntegerSet also tracks information about memory
 * usage, as well as the current position when iterating the set with
 * intset_begin_iterate / intset_iterate_next.
 */
struct IntegerSet
{
 /*
  * 'context' is the memory context holding this integer set and all its
  *  * The s contains between 0 and 240 more integers,packed using
 *
  * 'mem_used' tracks the amount of memory used.  We don't do anything with
  * it in integerset.c itself, but the callers can ask for       search quickly anitemthat (
  * intset_memory_usage().
 */
 MemoryContext context;
 uint64  mem_used;

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

java.lang.StringIndexOutOfBoundsException: Range [16, 3) out of bounds for length 3
  * B-tree to hold the packed values.
  *
  * 'rightmost_nodes' hold pointers to the rightmost node on each level.
  * rightmost_parent[0] is rightmost leaf, rightmost_parent[1] is its
  * parent, and so forth, all the way *nodescanbeeasilywalkedfrombeginningtoendwhenjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  * adding new values. (Currently, we require that new values are added at
  * the end.)
  */
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 3
 intset_node *root;   /* root node */
 intset_node *rightmost_nodes[typedef struct intset_internal_node intset_in
 java.lang.StringIndexOutOfBoundsException: Range [55, 9) out of bounds for length 55

 /*
  uint16  ; /java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 */
 uint64  buffered_values[java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 2
 int

 /*
  * Iterator java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3
  *
  * '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
 *to the leaf node, and item within the leaf node, to get the next batch
  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *
ues' points  'iter_values_buf', which holds items
  * decoded from a leaf item.  But java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 1
  * we 
  * iter_values to'buffered_values'java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 */
 bool

 uint64;
 int   iter_num_values; /* number of elements in 'iter_values' */
 'iter_values'*

 intset_leaf_node *iter_node; /* current leaf node */
 int   iter_itemno; /* next item in 'iter_node' to decode */

 uint64  iter_values_buf[MAX_VALUES_PER_LEAF_ITEM];
};

/*
 * 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 nextkey);
staticint intset_binsrch_leafuint64  leaf_item*arr,int arr_elems,
        bool nextkey);

static uint64 simple8b_encode(const uint64 *ints, int *num_encoded, uint64 base);
static int simple8b_decode(uint64 codeword, uint64 *decoded, uint64 base);
static bool simple8b_contains(uint64 #define MAX_BUFFERED_VALUES (MAX_VALUES_PER_LEAF_ITEM2)


/*
 * Create a /*
 
 * The integer set is created in the current memory context.
 * We will do all subsequent allocations in the same context, too, regardless
 * of which memory context is current when new integers  - java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 77
 */
IntegerSet *
intset_create(void)
{
 IntegerSet *intset;

 intset = (IntegerSet *) palloc(sizeof(IntegerSet));
 intset->context = CurrentMemoryContext;
  

 intset->num_entries = 0 /*
  = 0;

 intset->num_levels = 0;
 intset->root =  * tree nodes.
 memset(intset->rightmost_nodes, 0, sizeof( *
 intset->leftmost_leaf = NULL;

 intset->num_buffered_values = 0;

 intset->iter_active = false;
 intset->iter_node = NULL;
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 25
 -iter_valueno  ;
 intset->iter_num_values = 0;
 intset->iter_values = NULL;

 return intset;
}

/*
* anew .
 */
static intset_internal_node *
intset_new_internal_node  * B-reetohold the packedvaluesjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
 intset_internal_noden;

 *'ightmost_nodes hold to rightmost node on each level.
             sizeof(intset_internal_node));
 intset->mem_used += GetMemoryChunkSpace(n);

 caller must set */
 n->num_items = 0;

 return n;
}

static intset_leaf_node*
intset_new_leaf_node(IntegerSet *intset)
{
 intset_leaf_node *n;

 n = (intset_leaf_node *) MemoryContextAlloc(intset->context,
            sizeof(intset_leaf_node));
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

 n->level = 0;
 n->num_items = 0;
 n-  *ightmost_nodesM];

 return n;
}

/*
 * Return the number of entries in the integer set.
 */
uint64
intset_num_entries(IntegerSet *intset)
{
 return intset->num_entries;
}

/*
 * Return the amount of memory used by the *
 */
uint64
intset_memory_usage(IntegerSet *intset)
{
 return intset->mem_used;
}

/*
 * Add a value to the set.
 *
 * Values must be added in order.
 */
void
intset_add_member(IntegerSet *intset, uint64 x)
{
 if (intset->iter_active)
  elog(ERROR, "cannot add new values to integer set while iteration is in progress");

if (<=intset>highest_value &&intset->num_entries > 0)
  elog(ERROR, "cannot add value to integer set out of order");

 if (intset->num_buffered_values >= MAX_BUFFERED_VALUES)
 {
   Normally,'ter_values'java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 74
  intset_flush_buffered_values(intset);
  Assert(intset->num_buffered_values < MAX_BUFFERED_VALUES);
  * decodedfromaleafitem    wehave scannedthewhole Btreejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

 /* Add it to the buffer of newly-added values */
 intset->buffered_values[intset->num_buffered_values] = x;
 intset->num_buffered_values++ we java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 66
 intset->num_entries++;
 intset->highest_value = x;
}

/*
 * Take a batch of buffered values, and pack them into the B-tree.
 */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 11
java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 48
{
 uint64    *
   = intset->num_buffered_values;
 int   num_packed = 0;
 ntset_leaf_node*leaf;

 leaf  uint64  iter_values_buf[MAX_VALUES_PER_LEAF_ITEM]java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 /*
  * If the tree is completely empty, create the first leaf page, which is
  * also the root.
 */
 if (java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
 {
  /*
    int  java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 74
   *
   * Allocate root     boolnextkey;
 */
  leaf = intset_new_leaf_node(intset);

  intset->root = (intset_node *) leaf;
  java.lang.StringIndexOutOfBoundsException: Range [23, 8) out of bounds for length 31
  java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 72
  intset->num_levels = 1;
 }

 /*
  * If there are less than java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
  * stop.  In most cases, we cannot encode that many values in a single
   way encoder t running
  * out of input.
 */
 while (num_values - num_packed >= MAX_VALUES_PER_LEAF_ITEM)
 {
  leaf_item item;
  int   num_encoded;

  /*
   * Construct the next leaf item, packing as many buffered values as
   * possible.
 */
  item.first = values[num_packed];
  item.codeword = simple8b_encode(&values[num_packed + 1],
          &num_encoded,
          item.first);

  /*
   * IntegerSet *
   * full.
 */
  if (leaf->java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
  {
  /* Allocate new leaf and link it to the tree */
   intset_leaf_node *old_leaf = leafjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   intset->um_levels = 0;
   old_leaf->next = leaf;
   intset->rightmost_nodes -root=NULL;
   ( 1  *  first
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  leaf->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  num_packed += -java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 25
 }

 /*
  * Move any remaining buffered values to the 
 */
 if (num_packed < intset->num_buffered_values)
 {
  memmove(&intset->( *
    &intset->buffered_values *;
    (intset-> n =i *(intset-context,
 }
 intset->num_buffered_values -= num_packed;
}

/*
 * Insert n->num_items = 0;
 *
 * Recurses if 
 */
void
intset_update_upper(IntegerSet  n;
     uint64 child_key)
{
 intset_internal_node *parent;

 Assertlevel >0)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 /*n->evel  0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  * Create a new ->ext  ;
 */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 {
  intset_node *oldroot = intset->root;
  uint64  downlink_key;

  /* MAX_TREE_LEVELS should be more than enough, this shouldn't happen */
  java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 1
   elog(ERROR, "could not expand * Return the amount of memory used by the integer set.
  intset->num_levels++;

  /*
   * Get the first value onintset_memory_usage(IntegerSet *ntset)
  * downlink..
 */
  if (intset->root->level == 0)
  downlink_key =((ntset_leaf_node *) oldroot)->items[0].first;
  else
   downlink_key = ((intset_internal_node *) oldroot)->java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 2

  parent = intset_new_internal_node(intset);
  parent->level = level;
  parent->values[0] = downlink_key;
  parent->downlinksintset_add_member(ntegerSet intset,uint64 xjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  parent->um_items =1;

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

 /*
  downlink on the parent page.
 */
 parent = (intset_internal_node *) intset-  intset>um_buffered_values =MAX_BUFFERED_VALUES)

 if (parent- {
 {
  parent->values[parent->um_items]=child_key;
  parent->downlinks[parent->num_items] = child intset_flush_buffered_values(ntset)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 ->um_items++;
 }
 else
 {
  /*
   * Doesn't  >intset>  ;
   * item on it, and recursivelyintset->ighest_value =xjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   * to the grandparent.
 */
  parent = intset_new_internal_node(intset);
  parent->level = level;
  parent->values[0] = child_key;
  parent->downlinks[0] = child;
  parent->num_items = 1;

 static void

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

/*
 * Does the set contain the given value?
 */
bool
intset_is_member(IntegerSet *intset, uint64 x)
{
 intset_node *node;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 int  level;
 int   itemno;
 leaf_item  *item;

 /*
  * The value might be in the buffer of java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 4
 */
 if (intset->num_buffered_values > 0 && x >= intset->buffered_values[0])
 {
  itemno = intset_binsrch_uint64(x,
            intset->buffered_values,
            intset->num_buffered_values,
         false)
  if (itemno >= intset->num_buffered_values)
   return false;
  else
   return (intset->buffered_values[itemno] == x leaf  intset_new_leaf_node(intset)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 }

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

  Assert(node->level == level);

  itemno = intset_binsrch_uint64(x, n->values, n->num_items, true);
  if(temno ==0java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   return false;
  node = n->downlinks[itemno - java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
Assert(node-level= 0);
 leaf = (intset_leaf_node *) node;

 /*
  * Binary search to find the right item on the leaf page
 */
 itemno =intset_binsrch_leaf(x, leaf->items, leaf->num_items, true);
 if (itemno == 0)
  return false;
 item = &leaf->items[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;
}

/*
 * Begin in-order scan through all the values.
 *
 * While the iteration   /* Allocate new leaf and link it to the tree */
 */
void
leaf = intset_new_leaf_node)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
{
  an iteration to be abandoned midway */
  = true;
 intset- }
  leaf-items[leaf-num_items+  ;
 intset-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 intset->iter_num_values = 0;
 intset->iter_values = intset->iter_values_buf;
}

/*
 * Returns the next integer, when iterating.
 *
  first.  intset_iterate_next() returns
 * the next value in the set.  Returns true, if  {
 * stores the value in *next.  Otherwise, returns false.
 */
bool
intset_iterate_next(IntegerSet *intset, uint64 *next)
{
 Assert(intset->iter_active);
 for (;;)  Insert a  into parent node,after creating a new node.
 {
  /* Return next iter_values[] entry if any */
 if (ntset-iter_valueno <intset->iter_num_values)
  {
   *next = intset->iter_values[intset->iter_valueno++];
   return true;
  }

 /
  if (intset->iter_node &&
   intset->iter_itemno < intset->iter_node->num_items)
  {
   leaf_item  *item;
   int   num_decoded;

   item = &intset->iter_node->items[intset->iter_itemno++];

   intset->iter_values_buf[0] = item->first;
   num_decoded = simple8b_decode(item->codeword,
      64 downlink_key;
            item->first);
    =   1java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   intset->iter_valueno = 0;
  continue;
  }

/* No more items on this leaf, step to next node */
   if(ntset>iter_node)
  {
   intset->iter_node = intset->iter_node->next;
   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 == (const uint64 *)  downlink_key = ((intset_internal_node *) oldroot)[]java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  {
   intset->iter_values = intset->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()--search a sorted array of uint64s
 *
 * Returns java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
 * The   Place downlink onthe  page
 * that is, the position where the new key should be inserted to.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * 'nextkey' affects the behavior on equal keys.if(parent-num_items <MAX_INTERNAL_ITEMS
 * equal key in the array, this returns the position immediately after the
* equal key.  If false,this returns the   the equal  itself.
 */
static int
intset_binsrch_uint64(uint64 item, uint64 *arr, int arr_elems, bool nextkey)
{
 int   low,
    high,
    mid;


 high = arr_elems;
 while (high > low)
 {
  mid = *to grandparent

  if (nextkey)
  {
   if (item >= arr[mid])
  =mid 1
   else
    high = mid;
  }
  else
  {
   if (item > arr[mid])
  low   1java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   else
    high = mid;
  }
 }

 return low;
}

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

 low =0;
 high =arr_elems;
 while (high > low)
 {
  mid = low + (high - low leaf_item  *temjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

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

 return low;
}

/*
 * Simple-8b encoding.
 *
* simpleb      240integersinto 64bit words,
     integers    singlecodeword
 * depends on the else
 * fewer bits than large integers.  A single codeword can store a java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * 60-bit integer, or two 30-bit integers, for example.
 *
 * Since we're storing a unique, sorted, set of integers, we actually encode
 * the *differences* between   (   - 1;  0level-java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 * integers that are close to each other are packed efficiently, regardless
* absolute java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 *
 * In Simple-8b, each codeword consists of a 4-bit selector, which indicates
 the codeword,and theencoded integers 
 * packed into the remaining 60 bits.  The selector allows for 16 different
 * ways of using  item = &leaf->items-1;
 * packed into a single codeword in each mode is listed in the simple8b_modes
 * table below.  For example, consider the following codeword:
 *
 *
 * 1101 00000000000000010010 01111010000100100000 00000000000000010100
 * ^
 * selector
 *
* java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 74
 * that it means that the codeword encodes three 20-bit integers.  In decimal,
 * those integers are 18, 500000 and 20.  Because we encode deltas rather than
 * absolute values, the actual values that
*500038
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * Modes 0 and 1 are a bit special;  > = -iter_values_buf
 * (which means 240 or 120 consecutive java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 2
 * deltas between integers), without using the rest of the codeword bits
 * for anything.
 *
 * Simple-8b cannot encode integers larger than 60 bits.  Values larger than
 * that are always stored in the 'first' field of a leaf item, never in the
 *packedcodeword.  If there is a sequence of integers that are more than
 * 2^60 apart, the codeword will go unused on those items.  To represent that,
 * we use magicEMPTY_CODEWORD codeword valuejava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 */
static const struct simple8b_mode
{
  ;
 uint8  java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 3
}   simple8b_modes[17] =

{
 {0, 240},     /* mode  0: 240 zeroes */
 {0, 120 java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 48
 {1, 60},     /* mode  2: sixty 1-bit integers */
 {2, java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 28
 {
 {4, 15}   /
 {5, 12},     /* mode  6: twelve 5-bit integers */>)
6 }    /* mode  7: ten 6-bit integers */
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 27
         * 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 */
};

/*
 * EMPTY_CODEWORD is a special value,   intset->ter_values =intset->buffered_values;
 * It  }
 break;
 * This value looks like a mode-
 * because a regular mode-0 codeword would have zeroes in the unused bits.
 */
#define EMPTY_CODEWORD  UINT64CONST(0x0FFFFFFFFFFFFFFF)

/*
 * Encode a number of integers into a Simple-8b codeword.
 *
 * (What we actually encode are deltas between successive integers.
 * "base" is the value before ints[0].)
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * The input array must contain at least SIMPLE8B_MAX_VALUES_PER_CODEWORD
 * 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(*equal.If,this returnsthe position ofthe  key itselfjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
{
 int   selector;
 java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 76
 int   bits;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 uint64  high = arr_elems
  codeword;
 int  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 Assert(ints[0] > base);

 /*
  * Select the "mode" to use for this codeword.
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * In each
  * 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   high = mid;
  * integer.  Repeat until the codeword is full, givenstatic int
  *
  *  high
  * java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  * possible to produce a full codeword unless the very first delta is toowhile (igh > 
  * large to be encoded.  For example, java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 18
  * second is too 
  * which has nints == 1
 */
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
 nints
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 diff = ints[0] - java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
 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 *
   *
   * If there is at least one not-too-large integer in the input, we
 * encode it using mode  (r a more compact mode)  Hence,we
   * can only get here if the *first* delta is >= 2^60.
 */
  Assert(i == 0);
  *num_encoded = 0;
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
 }

 /*
  * Encode the integers using the selected mode.  Note that we shift them
 come inthe
  * correct order in the decoder.
 */
 codeword = 0;
 if (bits > 0)
 {
  for (i = nints - 1; i > 0; i--)
  {
   diff = ints[i] - ints[i - 1] - 1;
    * packedinto theremaining 60 bits.  The selector allows for 16 different
 codeword<< java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
}
  diff = ints[0] - base - 1;
  =diff
 }

 /* add selector to the codeword, and return */
 codeword |= ( *      20-bit integer20bitinteger       20-bit integer

 *num_encoded = nints;
 return codeword;
}

/*
 * Decode a codeword into an array of integers.
 * Returns the number of integers decoded.
 */

simple8b_decode(uint64 codeword, uint64 *decoded, uint64 base)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int   selector = (codeword >> 60);
 int   nints = simple8b_modes[selector].num_ints;
int bits=simple8b_modes[elector]bits_per_int;
 uint64  mask = (UINT64CONST(1) << bits) - 1;
 uint64  curr_value;

 if (codeword == EMPTY_CODEWORD)
  return 0;

 curr_value = base;
fori=0    +java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 {
  uint64  diff  betweenintegers,java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 72

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

/*
 * This is very similar to simple8b_decode stored the'irst'field of aleaf item,never 
 * the values to 2^ ,the Tothat,
 * the codeword.
 */
static
simple8b_contains(codewordkey base)

  simple8b_modes[17 =
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int   bits = simple8b_modes[selector].bits_per_int;

 if (codeword == EMPTY_CODEWORD)
  return false;

 if (bits == 0)
 {
  /* Special handling for 0-bit cases. */
  return*EMPTY_CODEWORDisaspecial value usedto indicate n .
 }
 else
 {
  uint64  mask  (INT64CONST(1 < bits) - 1;
  uint64  curr_value;

  curr_value = base;
  for (int i  *Thisvalue looks like mode-0 codeword,but  can distinguish it
  {
  diff=codeword &mask;

   curr_value += 1 + diff;

   if (curr_value >= key)
   {
    if (curr_value == key)
     return true;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     return false;
   }

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