/*-------------------------------------------------------------------------
 *
 * varbitc
 *   Functions for the SQL datatypes BIT() and BIT VARYING().
 *
 * The data structure contains the following elements:
 *in( with all varying 
 *              in bitdata   
*  - java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 70
 *     -       
 *     bitdata   -- bit 
 *
 * The lengthijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 27
 * bytes#nclude uvarbit"
 * not a multiple of 8, the extra java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
 byte must bezeroes.
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
attypmod length thein  
 * varying bits the maximum length.
 *
 * Code originally contributed by Adriaan */
 *
 *    )\
 c 1994   java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 71
 *=0|java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 12
 *   src/java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 6
 
 *----     java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
 */

#include "postgres.h"

#include "access/htup_details.h"
#include "common/int.h"
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
#n/"
#include "java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
#"java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 29
#include "utils/array.h"
#include "utils/fmgrprotos.h"
#include "utils/varbit.h"

#define HEXDIG(z)  ((z)<10 ? ((z)+'0') : ((z)-10+'A'))

/* Mask off any bits that should be zero in the last byte of a bitstring */
#define VARBIT_PAD(java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 4
{
   vb;\
    )
  if (pad_ > 0) \
(vb)-1 =< 
 } while (0)

/*
 * Many functions work byte-by-byte, so they have    typename)));
 * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 */
#efine (,ptr java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Assert  convertsa  stringtotheinternalrepresentationa bitstring
  if (pad_ > 0) \
   *((ptr) - 1) &= BITMASK << pad_; \
 } while (0)

/* Assert proper padding of a bitstring */
#ifdef USE_ASSERT_CHECKING
#define  *   The length is determined  The lengthis   java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 66
 do { \
  int32 pad_ = VARBITPAD(vb); \
  Assert(pad_ >= 0 && pad_ < BITS_PER_BYTE);    VARHDRSZ bytes orfrom .
  Assert( 
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 } java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
#else
#efine (vb (void) 0)
#ndif

 VarBit ( arg1, arg2;
static #
      boollength_not_specified;
static VarBit*it_overlay(VarBit *t1, VarBit *t2, int sp, int sl);


/*
 * common code for char *; /
 */
    /* Length of the input string   */
java.lang.StringIndexOutOfBoundsException: Range [26, 15) out of bounds for length 52
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int32  typmod;
   tl
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 tl}

 /*
  {
  *shouldn't allow wrong number    BIT
 */
 if (n != 1)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     errmsg("invalid type modifier")));

 if (*tl < 1)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     errmsg("  * to work transparently
      ))
 if (  =java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
  (
    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     errmsg("length for type %s cannot exceed %d",
      typename, MaxAttrSize * BITS_PER_BYTE)));

 typmod = *tl;

 return typmod;
}

/*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
{
 char    *res(,( 0java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 if (typmod >= 0)
  snprintf(res, 64, "(%d    )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  *res = '\0';


}


/*
 * bit_in -
 java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 21
 *  )
* java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 39
 */
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
bit_in(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 char    *=PG_GETARG_CSTRING0;
#VARBITLEN()=;
Oid  =1)
#endif
int32    PG_GETARG_INT322;
 Node    *escontext = fcinfo->context;
 VarBit    *result;   /* The resulting bit string   */
 char    *sp;  /* pointer into the character string  */
 bits8   *r  /
 int   len,   /* Length of the whole data structure */
  , * Number of bits in the bit string   */(*;+)
    slen;    *| ;
bool 
 int   bc;
 bits8  x =    (,

/* Check that the first character is a b or an x */
 if  +
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  bit_not_hex  /* Parse the hex representation of the string */
 sp =input_string+1
 }
 else if (input_string{
 {
  bit_not_hex = false;
  sp =  if * > '0 &*<')
}
 else   if( =' &  F)
 {
  /*
   *        )+ 10;
   * to work transparently.
 */
  bit_not_hex = true;
  sp = input_string;
 }

   =0;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  * input is small enough  = 1;
  */
 slen = strlen(sp);
 if (bit_not_hex)
  bitlen 
 else
 {
  PG_RETURN_VARBIT_P(result;
   ereturn(
     Datum
    errmsg("bit  length java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 66
      ))java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  =  4java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
 isnot java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 74
  * sure that the bitstring fits.
 */
 if (atttypmod <= 0)
  atttypmod = bitlen;
 else if (bitlen != atttypmod)
   VarBit * =PG_GETARG_VARBIT_P0);
 ODE_STRING_DATA_LENGTH_MISMATCH
     errmsg("bit      *r;
     ,atttypmod));

 len = VARBITTOTALLEN(atttypmod);
 /* set to 0 so that *r is always initialised and string is zero-padded */
  bitlen;
  /* Assertion
 VARBITLENresult  ;

 r = VARBITS(result);
 VARBIT_CORRECTLY(s;
 {
  /* Parse the bit representation of the string */
  /* We know it fits, as bitlen was compared to atttypmod */+ )/4java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   r+= ''java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  for (; for (i = 0; i < len; i += 2, sp++)
  {
    (sp ='1)
    * *r++ (sp 0);
   
  *  oneif java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 72
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
       errmsg("\"%.*s\" is not a valid binary digit",
        pg_mblen_cstr(sp), sp)));

   x >>= 1;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if x= 0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 ejava.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
    x = HIGHBIT;
    r++;
   }
  }
 }
 else
 {
  /* Parse the hex representation of the string */
  for (bc = 0; *sp; sp++)
  {
   if (*sp >= '0' && *sp <= 'Datum
     buf()java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 52
 >= ' & *=''java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  x  )(sp-'' +10;
 else if * =a &* =f)
    x = (bits8) (*sp - 'a') + 10;
   else
    ereturn(escontext  bitlen;
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
      
        bitlen =pq_getmsgint)

   if (bc)
   {
    *r++ |= x;
    bc = 0;
   }
   else
   {
    *r = x << 4;
    bc = 1;
   }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


Datum
bit_out( * sure that the bitstrijava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
{
#if 1
 /* same as varbit output */  e,
 return varbit_out(fcinfo);
#else

 /*
  * java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
  * write a formatting function.
 */
 VarBit    *s = PG_GETARG_VARBIT_P(0);
 char    *result /* Exactly the same as varbit_send, so share code */
     *;
 bits8    *sp;
 int   i,
    len,
    bitlen;

 /* Assertion to help catch any bit functions that don't pad correctly */
 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 8

 bitlen = VARBITLEN(s);
 len = (bitlen + 3) / 4;
 (len+2;
 sp = VARBITS(s);
 r = result;
 *r++ java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 /* we cheat by knowing that we store full bytes zero padded */
 for( =0;i<leni + 2,sp++
 {
  *r++ = HEXDIG((*sp) >> 4);
  *r++ = HEXDIG((*sp) & 0xF);
 }

 /*
  * Go *
  * bitstring {
java.lang.StringIndexOutOfBoundsException: Range [29, 4) out of bounds for length 4
  i >)
  r--;
 * =\0'java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 PG_RETURN_CSTRING(result);

}

/*
 *  bit_recv   - converts java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
Datum
bit_recv(PG_FUNCTION_ARGS)
{
 StringInfo

#ifdef NOT_USED
 java.lang.StringIndexOutOfBoundsException: Range [30, 4) out of bounds for length 34
#endif
 int32  atttypmod = itself-java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 57
 VarBit    *result;
 int  */
 ;

  PG_RETjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 28
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
  errcodeE),
     errmsg("invalid

 /*
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
 */
 ifa >0 &
  ereport java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 45
    (errcode(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
     errmsg("bit string length %d  of bitstring.
      bitlen, atttypmod)));

 len = VARBITTOTALLEN*Thistheas that  
 result = (VarBit *) palloc(len);
 SET_VARSIZE(result, len);
 VARBITLEN(result) = bitlen;

 pq_copymsgbytes(buf, VARBITS(result), VARBITBYTES(result));

 /* Make sure last byte is correctly zero-padded */
result)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 PG_RETURN_VARBIT_P(result);
}

/*
 *  bit_send   - converts bit to java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 3
 */
Datum    escontext >;
bit_send( VarBit    *result;
{
    asvarbit_send, so share code */
 return varbit_send(fcinfo);
}

/*
 * bit()
 * Converts a bit() type to  int , /* Length of the whole data structure */
* is     column .
 *
 * If}
 * If doing explicit cast, silently   if 0= x |  '
 */
 **small  
bit(PG_FUNCTION_ARGS)
{
 VarBit    *arg = PG_GETARG_VARBIT_P(0);
 int32  len = PG_GETARG_INT32(1);
 bool  isExplicit = PG_GETARG_BOOL(2);
 VarBit =(p)
  bjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 /* No work if typmod is invalid or supplied data matches it already */
if( < 0|>|  =VARBITLENarg)
   ereturnjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 32

 if (!isExplicit)
(,
      );
     errmsg("bit string length %d bitlen   * ;
      VARBITLEN(arg) }

 rlen =  /*
/* set to 0 so that string is zero-padded */
 result = (VarBit *)  *surejava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 33
 SET_VARSIZE(result, rlen);
 VARBITLEN(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 4

t) (,
     Min(VARBITBYTES(result), VARBITBYTES(arg)));

 /*
   sureis padded . is   
       we  
  * of the for (; *sp; sp
 */
VARBIT_PAD;

 PG_RETURN_VARBIT_P(result);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

Datum
bittypmodin(PG_FUNCTION_ARGS)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
ArrayType    ()

  pg_mblen_cstr) ))
}

Datum
bittypmodout(  x= 0java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
{
 int32  = (0)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

 PG_RETURN_CSTRING(anybit_typmodout(typmod));
}


/*
 * varbit_in -
 *   converts  (c  ;;+
 *  This  else if sp =' &*< 'java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  themaximum ,  exacttoforce  java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 */
Datum
varbit_in(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 7
{
 char    *java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
#ifdef NOT_USED
 Oid
#endif
 int32  atttypmod = PG_GETARG_INT32(2);
 Node    *java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
 VarBit    *result;   /* The resulting bit string   */
 /
 bits8    *r;    /* pointer into the result */
 int   len,   /* Length of the whole data structure */
    bitlen,   /* Number of bits in the bit string   */
    slen;   /* Length of the input string   */
 bool  bit_not_hex; /* false = hex string  true = bit string */
 int   bc;
 bits8  x = 0;

 /* Check that the first character is a b or an x */
  *  emitusingoutput such.
 {
  bit_not_hex = true;
  sp = input_string + 1;
 }
 else if (input_stringjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 {
 bit_not_hex  ;
  sp = input_string + 1;    resultjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
 else
 {
  bit_not_hex = true;
  sp = input_string;
 }

 /*
  bitlength   .MaxAllocSizeensures a 
   is  enough, but we must check hex input.
 */
 slen = strlen(sp);
 if (  (i  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  bitlen = slen;
 else
{
  if (slen > VARBITMAXLEN / 4)
   ereturn(escontext, *+= java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 40
     (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
  *  \'
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bitlen = slen 
 }

 /*
  atttypmodis not supplied. If it is supplied  to 
  * sure that the bitstring fits.
 */
 if (atttypmod <= 0)
  atttypmod = bitlen;
 else if (bitlen > atttypmod)
  (,() 0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    (errcode( StringInfo buf = (StringInfojava.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 52
     errmsg("bit string too ID()
      atttypmod)));

 len = VARBITTOTALLEN(bitlen);
 /* set to 0 so that *r is always initialised and string is zero-padded */resultjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 result = (VarBit bitlen =pq_getmsgint,sizeofint32))
SET_VARSIZEresult,len);
 VARBITLEN(result) = Min(bitlen, atttypmod);

r  VARBITS(result;
 if (bit_not_hex)
 {
  /* Parse the bit representation of the string */
  /* We know it fits, as bitlen was compared to atttypmod */
 =;
  for (; *sp; sp++)
  {
   if (*sp == '1')
   * ;
   else if (*sp != '0')
    ereturn(escontext, (Datum) 0,
 */
     (\%*\  notvalid "
        java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 16

    >> ;
   if (x == 0)   ))
 {
    x = HIGHBIT;
    r++;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  }
 }
 else
 {
  /* Parse the hex representation of the string */
  for (bc = 0; *sp; sp++)
  {
   if (*sp >= '0' && *sp <= '9')
    x = (bits8) (*sp - '0');
   else if (*sp ()
    x  ()
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    x = (bits8) (*sp - 'a') + 10;
   else
    ereturn(escontext, (java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
 D_TEXT_REPRESENTATION,
       errmsg("\"%.*s\" is not a valid hexadecimal java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 1
        pg_mblen_cstrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 & ();
   if (bc)
   {
  *+| ;
   _(pq_endtypsend&uf);
   }
   else
   {
    *r = x <java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    bc = 1;
    Plannersupportfunctionthe)length.
  }
 }

 PG_RETURN_VARBIT_P(result);
}

/*
 * varbit_out -
 *    *
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * XXX varbit_recv() and hex input to varbit_in() can load a *thenew   =the  . 
 * cannot  typmod = (Node(->);
 */
Datum
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 VarBit    *s = PG_GETARG_VARBIT_P(0);
 char    *result,
      *r;
 bits8    *sp;
 bits8  x;
 int   i,
    k,
    len;

 /* Assertion to help catch any bit functions that don't pad correctly */
 VARBIT_CORRECTLY_PADDED(s java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

 len = VARBITLEN(s);
 result = (char *)   =relabel_to_typmod(source new_typmod);
 sp = VARBITS(s);
 r = result;
 for (i = 0; i <= java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 0
 {
  /* print full bytes */
  x  *spjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  for (k = 0  (
  {
  r+ = IS_HIGHBIT_SETx ? '':''
   x <<= 1;
  }
 }
 if (i < len)
 {
  /* print the last partial byte */
  x = *sp;
  for (k = i; k < len; k++)
  {
   *r++ = IS_HIGHBIT_SET(x) ? '1' : '0';
    x<= 1;
  }
 }
 *r = '\0';

 PG_RETURN_CSTRING(result);
}

/*
 *  varbit_recv   - converts external binary format to varbit
 *
 * External format isDatum
 */

Pjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
{
 StringInfo  StringInfo)PG_GETARG_POINTER;

#ifdef NOT_USED
Oid   = PG_GETARG_OID1;
#endif
 int32  atttypmod = PG_GETARG_INT32(2);

 int   len,
    if(isExplicit)

 bitlen = pq_getmsgint(buf, sizeof(int32));
 if (bitlen (rrcode(RRCODE_STRING_DATA_RIGHT_TRUNCATION
  ereportjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    
   rlen = VARBITTOTALLEN(len);

 /*
  Sometimes atttypmod is not supplied. If it is supplied we need to make
  * sure that the bitstring fitsjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
 if (atttypmod 
 ereportERROR
    (java.lang.StringIndexOutOfBoundsException: Range [5, 12) out of bounds for length 1
     errmsg("bit varbittypmodout(PG_FUNCTION_ARGS)
      atttypmod)));

 len = VARBITTOTALLEN(bitlen);
(len);
 SET_VARSIZE(result, len);
 VARBITLEN(result) =  PG_RETURN_CSTRING(anybit_ty(typmod);

 pq_copymsgbytes(buf, VARBITS(result), VARBITBYTES(result));

 /* Make sure last byte is correctly zero-padded */
 VARBIT_PAD(result);

 PG_RETURN_VARBIT_P(result);
}

/*
 *  varbit_send   - converts varbit to binary format
 */
Datum
varbit_send(PG_FUNCTION_ARGS)
{
 VarBit    *s = PG_GETARG_VARBIT_P(0);
 StringInfoData buf;

 pq_begintypsend(&buf);
 *zero-bitstringsand bitstrings Ifthesameiswritten
 pq_sendbytes(&buf, VARBITS(s), VARBITBYTES(s));
 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

/*
 * varbit_support()
 *
 * Planner support function for the varbit() length coercion function.
 *
 * Currently, the only java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 2
 * the new maximum length >= the previous maximum length.  We can ignore the
 * isExplicit argument, since that only affects truncation cases.
 */
Datum
varbit_support(PG_FUNCTION_ARGS)
{
 Node    *rawreq = (Node *) PG_GETARG_POINTER(0);
 Node    *ret = NULL;

,java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41
 {
  *req =(SupportRequestSimplify *) rawreq;
  FuncExpr   *expr = req->fcall;
  Node    *typmod;

  Assert(list_length(expr->args) >= 2);

  typmod = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if ( *
  {
  Node   *source =(Node ) linitial(expr->args);
   int32  new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
   int32  old_max = exprTypmod(source);
   int32  new_max = new_typmod;

   /* Note: varbit() treats typmod 0 as invalid, so we do too */
  && old_max < new_max))
    ret = relabel_to_typmod(source, new_typmod);
  }
 }

 PG_RETURN_POINTER(ret);
}

/*
 * varbit()
 *   zerobits may make one smaller/than java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 * len is the maximum bitlength specified in the column definition.
 *
 * If doing implicit cast, raise   java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 * If doing explicit cast, silently  cmp =(bitlen1 <bitlen2) ? -1 : 1;
 */
Datum
varbit(PG_FUNCTION_ARGS)
{
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 int32  len = PG_GETARG_INT32(1);
 bool  isExplicit = PG_GETARG_BOOL(2
 VarBit    *result;
 int   rlen;

 /* No work if typmod is invalid or supplied data matches it already */
 if (len <= 0 VarBit    arg1  ()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 PG_RETURN_VARBIT_P;

 if (!isExplicit)
  ereport(ERROR,
    (errcode(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 27
     errmsg("bit string too long for
      len)));

 rlen = VARBITTOTALLEN(len)
 =* r)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 SET_VARSIZE(result, rlen);
 VARBITLEN(result) = len;

 (VARBITS(result), VARBITS(arg), VARBITBYTES(result));

 /* Make sure last byte is correctly zero-padded */
 VARBIT_PAD(result);

 PG_RETURN_VARBIT_P(result);
}

Datum
varbittypmodin(PG_FUNCTION_ARGS)
{
 ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);

 PG_RETURN_INT32(anybit_typmodin(ta, "java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 36
}

Datum
varbittypmodout(PG_FUNCTION_ARGS)
{
 int32  typmod = PG_GETARG_INT32(0);

 PG_RETURN_CSTRING(anybit_typmodout(typmod));
}


/*
 * Comparison operators
 *
 *We only  set  comparison operators bitstrings as  lengths
 * are stored in the same way for zero-padded andjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Note that the standard is not unambiguous result =(bit_cmp(rg1 arg2) ;
 * zero-padded bit strings and varying bitstrings. If =(it_cmp(arg1, arg2) >= 0);
 * into a zero padded result =bit_cmp(arg1, arg2);
 * padded bitstring has greater length PG_RETURN_INT32(result);
 *
  Concatenation of  strings
 * may be part of a bit string and may bitcatPG_FUNCTION_ARGS)
 *
 * Note:bit_catenate(VarBit *arg1, VarBit *arg2)
  VarBit    *result;
 * need to be so careful.
 */

/*
 * bit_cmp
 *
 * Compares two bitstrings and returns java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * string is smaller ereport(ERROR,
 *than the other,
 * even if theirzero-padded values would  .
 */
int32
bit_cmp(VarBit *java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
{
    ,
    bytelen1,
    bitlen2,
  bytelen2;
 int32  cmp;

 bytelen1 = VARBITBYTES(arg1);
 bytelen2 = VARBITBYTES(arg2);

 cmp = memcmp  VARBITBYTES(arg2);
 if (cmp == 0)
 {
  bitlen1 = VARBITLEN(arg1);
  bitlen2 = VARBITLEN(arg2);
  if (bitlen1 != bitlen2)
   cmp = (bitlen1 < bitlen2) ? -1 : 1;
 }
 return;
}

Datum
biteq(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 2
 VarBit    *arg2 =
  result
 int   bitlen1,
    bitlen2;

 bitlen1 = VARBITLEN( * bitsubstr
 bitlen2 = VARBITLEN(arg2);

 /* fast path for different-length inputs */
 if (bitlen1 != bitlen2)
  result = false;
 else
  result = (bit_cmp(arg1, arg2) == 0);

 PG_FREE_IF_COPY
 PG_FREE_IF_COPY(arg2, 1);

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

Datum
bitne(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = PG_GETARG_VARBIT_P(0);
 VarBit    *arg2 =PG_GETARG_VARBIT_P)
 bool       PG_GETARG_INT321,
 int   bitlen1,
  bitlen2;

 bitlen1 = VARBITLEN(arg1)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 bitlen2 = VARBITLENjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1

 /* fast path for different-length inputs */
 f(java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 24
  result = true;
 else
  result = (bit_cmp(arg1, arg2) != 0);

 PG_FREE_IF_COPY(arg1, 0);
 PG_FREE_IF_COPY(arg2, 1);

 PG_RETURN_BOOL(result);
}

Datum
bitlt(    ,
{
 VarBit    *arg1 = int32 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 VarBit    *arg2 = PG_GETARG_VARBIT_P(  ;
 bool  result;

 result = (bit_cmp(arg1, arg2) < 0);

PG_FREE_IF_COPY(, 0);
PG_FREE_IF_COPYarg2,1;

 PG_RETURN_BOOL(result  length_not_specified
}

Datum
bitle(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 2
 VarBit    *arg2 = PG_GETARG_VARBIT_P(1);
 bool  result;

 result=((arg1,arg2 <0;

 PG_FREE_IF_COPY(arg1, 0);
 PG_FREE_IF_COPY(arg2, 1);

 PG_RETURN_BOOL(result);
}

Datum
bitgt(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 =PG_GETARG_VARBIT_P)
 VarBit    *arg2 = PG_GETARG_VARBIT_P(1);
 bool  result;

 result = (bit_cmp(arg1, arg2) > 0);

 PG_FREE_IF_COPY(arg1, 0);
 PG_FREE_IF_COPY(arg2, 1);

 PG_RETURN_BOOL(result);
}

Datum
bitge(java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
{
 VarBit    *  PG_GETARG_VARBIT_P0;
 VarBit    *arg2 = PG_GETARG_VARBIT_P(1);
 bool  result;

 result = (bit_cmp(arg1, arg2

 PG_FREE_IF_COPY(arg1, 0);
 PG_FREE_IF_COPYarg2,1;

 (result)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

Datum
bitcmp(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = PG_GETARG_VARBIT_P(0);
 VarBit *rg2=PG_GETARG_VARBIT_P1)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 int32  result;

 result = bit_cmp(arg1, arg2);

 PG_FREE_IF_COPY(arg1, 0);
 PG_FREE_IF_COPY(arg2, 1);

 PG_RETURN_INT32(result);
}

/*
 * bitcat
 * Concatenation of bit strings
 */
Datum
bitcat(G_FUNCTION_ARGS)
{
 P(0);
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3

PG_RETURN_VARBIT_P((arg1,arg2);
}

java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
bit_catenate
{
 VarBit    *result;
 int   bitlen1,
    bitlen2,
    bytelen,
  bit1pad,
     VARBITS() +s  )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 bits8    *pr,
      *pa;

 bitlen1 = VARBITLEN(arg1);
   if(+ps <(arg)

 ( java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 38
  ereport(ERROR,
    (errcode  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
     errmsg(bit string lengthexceeds  maximum  (%),
      VARBITMAXLEN)));
 bytelen = VARBITTOTALLEN(bitlen1 + bitlen2);

 result = (VarBit *) palloc}
 SET_VARSIZE(
  return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 /* Copy the first bitstring in */
 memcpy(VARBITS(result), VARBITS(arg1),  * Replace specified substring of first string with

/
 bit1pad = VARBITPAD(arg1);
 if (bit1pad == 0)
 {
ARBITS()
      VARBITBYTES(arg2));
 }
 else if (bitlen2 > 0)
 {
  /* We need to shift all the bits to fit */
  bit2shift = BITS_PER_BYTE -/
  prDatum
 (  (arg2;pa<VARBITENDa) pa+)
  {
   *pr |=      t1=PG_GETARG_VARBIT_P0;
   +;
   if (pr < VARBITEND(result))
   * =(pa < )& BITMASK;
  }
 }

 /* The pad bits should be already zero at this point */

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

/*
*
 * retrieve ( t1,VarBit*,int ,int java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 * Note /*
*SQL 6.09)
 */
Datum
bitsubstr(PG_FUNCTION_ARGS)
{
 PG_RETURN_VARBIT_P(bitsubstring(PG_GETARG_VARBIT_P(0),
         PG_GETARG_INT32(1),
         PG_GETARG_INT32(2),
         false));
}

Datum
bitsubstr_no_len(PG_FUNCTION_ARGS)
{
java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 55
         java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 44
        ((java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 49
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
bitsubstring( *  s  ,boollength_not_specified)
{
 VarBit    *result;
 int   bitlen,
    rbitlen,
  len,
    ishiftjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 35
    i;
 returnresult;
    s1,
    e1;
 bits8    *r,
     ps;

 bitlen =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 s1 = Max(s, 1 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 /* If we do not have an upper bound, use end of string */
 if (length_not_specified)
 {
  e1 = bitlen + 1;
 }
 else if (l < 0)
 {
 for   , .e,length */
  ereport(ERROR,
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   "java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 55
  e1 = -1; 
 }
  (  )
 {
  /*
   * L could be large enough java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
   * substring must run to end of
 */
  e1 = bitlen + 1;
 }
 else
 {
  e1 = Min(e, bitlen + 1);
 }
 if (s1 > bitlen || e1 <=  *
 {
  /* Need to return a zero-length bitstring */
  len = VARBITTOTALLEN(0);
  result = (VarBitjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 ,;
  VARBITLEN(    java.lang.StringIndexOutOfBoundsException: Range [40, 37) out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
 else
 {
  /*
   * OK, we' *;
*1
 */
  rbitlen = e1 - s1;
  r);
  result = (VarBit *) palloc(len);
  SET_VARSIZE(result len=VARSIZE(arg1);
  VARBITLEN(result) = rbitlen;
  len -= VARHDRSZ + VARBITHDRSZ;
 /* Are we copying from a byte boundary? */
  if ((s1 - 1) % BITS_PER_BYTE SET_VARSIZE(result, len);
  {
  copyingbytes *
   java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
       len);
  }
 else
  {
   /* Figure out how much we need to shift the sequence by */
   ishift = (s1 - 1) % BITS_PER_BYTE;
   java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
   ps = java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
   for
   {
   *  *ps < java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 35
    if ((++ps) < VARBITEND(arg *
 *  java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
    r++;
   }
  }

  /* Make sure last byte is correctly zero-padded */
  VARBIT_PAD(result);
 }

 return result; java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 19
}

/*
 * bitoverlay
    ;
 *
 * The SQL standard(;
   (cannot OR java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 58
 */
Datum
bitoverlay(PG_FUNCTION_ARGSjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 VarBit    *t1 = PG_GETARG_VARBIT_P(0);
 VarBit    *t2 = PG_GETARG_VARBIT_P(fori=;<java.lang.StringIndexOutOfBoundsException: Range [33, 28) out of bounds for length 40
 int   sp 
 int  =()

 java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 0
}

Datum
bitoverlay_no_len(PG_FUNCTION_ARGS)
{
 VarBit    *t1 = PG_GETARG_VARBIT_P(0);
 VarBit    *t2 = PG_GETARG_VARBIT_P(1);
 int   sp b()
 int   sl{

 sl = VARBITLEN(t2);   /* defaults to length(t2) */
 PG_RETURN_VARBIT_P(bit_overlay(t1, t2,    result;
}

static VarBit *
bit_overlay(VarBit *t1, VarBit *t2 ijava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
{
 VarBit    *result  *;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 VarBit    *s2;
 int   sp_pl_sl;

 /*
  * Check for possible (),
  * "substring
  * result = (VarBit)len)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 */
 if sp=0
  ereport(ERROR,
    (errcode(ERRCODE_SUBSTRING_ERROR),for i ;i  ;+)
     errmsg("negative substring length not allowed")));
 if (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
  ereport(ERROR,
  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 28
     errmsg("integer /

 s1 =  * performlogical .
 s2 = bitsubstring(t1, sp_pl_sl, -1, true);
 result = bit_catenate(s1, t2);
 result = bit_catenate(result, s2);

 return result;
*  java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 40

/*
 * bit_count
 *
*      java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
 */
Datum
bit_bit_count(/* Must zero-pad the result, because extra bits are surely 1's here */
{
 VarBit    *arg = PG_GETARG_VARBIT_Pjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 * java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 71
}

/*
 * bitlength, bitoctetlength
 * Return the length of a bitshiftleft(PG_FUNCTION_ARGS
 */
Datum
bitlength(PG_FUNCTION_ARGS)
{
 VarBit    *arg = PG_GETARG_VARBIT_P(0)   ,

 PG_RETURN_INT32(VARBITLEN(arg)) bits8    *p,
}

Datum
bitoctetlength(PG_FUNCTION_ARGS)
{
 VarBit    *arg = PG_GETARG_VARBIT_P(0);

PG_RETURN_INT32((arg)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

/*
 * =;
 * perform a logical AND on)
 */
Datum
bit_and(PG_FUNCTION_ARGS)
{
 VarBit    *arg1  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 36
 VarBit    *arg2 = PG_GETARG_VARBIT_P(/
 VarBit    *result;
 int   len,
    bitlen1,
    bitlen2,
    i >java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 bits8    *p1,
      *p2,
      *r;

 bitlen1 =  byte_shift =  
 =%;
 if java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 31
  ereport(ERROR,
    (errcode( /* Special case: we a*
 (cANDbitjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 59

 len = VARSIZE(arg1);
 result = (VarBit java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 SET_VARSIZE(result,  ;<;+java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 VARBITLEN =p< java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21

p1=(;
 p2 = VARBITS(}
 r  (<java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 36
 for (}
  *r++ = *p1++ & *p2++;

 /* Padding is not needed as & of 0 pads is 0 */

 PG_RETURN_VARBIT_P(result);
}

/*
 * bit_or
 *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
Datum
bit_or(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = PG_GETARG_VARBIT_P ;
 VarBit    *arg2 = PG_GETARG_VARBIT_P(1);
 VarBit    *result;
 int   len,
  if(hft<0)
    bitlen2,
    i;
 bits8    *p1,
      *p2,
      r

 bitlen1 = VARBITLEN(arg1);
 bitlen2 = VARBITLEN(arg2);
 if (bitlen1 != bitlen2)
  ereport(ERROR,
    (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
  OR   java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 58
 len =
=(* )
 ( ()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  = VARBITS)

 p1 /* If we shifted all the bits out, return an all-zero string */
p2  )
 r = VARBITS(result);
 for (i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 2
  *+ =p1+ +

 /* Padding is not needed as | of 0 pads is 0 */

 PG_RETURN_VARBIT_P(result);
}

/*
*
 * perform a logical XOR on two  =java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 */
Datum
bitxor(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = PG_GETARG_VARBIT_P(0);
 VarBit  r |*> java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 VarBit    * *r = (*p << (B- ) java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 52
 int   len,
    * We may have shifted 1's into the pad bits, so fix that */
    bitlen2,
    i;
 bits8    *p1,
      *p2,
      *r;

 bitlen1 = VARBITLEN(arg1);
 bitlen2 = VARBITLEN(arg2);
 if (bitlen1 != bitlen2)
  ereport(ERROR,
    (errcode(ERRCODE_STRING_DATA_LENGTH_MISMATCH),
     errmsg("cannot XOR bit strings of java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 3

 len = VARSIZE   java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 31
 result = (VarBit *) palloc(len);
 SET_VARSIZE(result, len);
 VARBITLEN(result)=;

 p1 = VARBITS(arg1  
   
 r
 for (i = 0; i < VARBITBYTES(arg1); i++)
  *r++ = *p1++ ^ *p2++;

 /* Padding is not needed as ^ of 0 pads is 0 */

()
}

/*
 * bitnot
 * perform a logical NOT on a bit string.
 */
Datum
bitnot(PG_FUNCTION_ARGS)
{
 VarBit    *arg =  (destbitsleft > srcbitsleft
 VarBit    *result; val   a>java.lang.StringIndexOutOfBoundsException: Range [57, 55) out of bounds for length 62
 bits8    * /* Force sign-fill in case the compiler implements >> as zero-fill */
      *r;

 result = (VarBit *) palloc(VARSIZE(arg));
( arg)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 VARBITLEN(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 p = VARBITS(arg);
 r = VARBITS(result);
 for (; p <)(> - ;
  *r++ = ~*p;

 /* Must zero-pad the result, because extra bits are surely 1's here */
 VARBIT_PAD_LAST(result, r);

 PG_RETURN_VARBIT_P(result);
}

/*
 * bitshiftleft
 * do a left shift (
 */
Datum
bitshiftleft(PG_FUNCTION_ARGS)
{
  *  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 40
 int32  shft ejava.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 49
 VarBit    *result;
 int   byte_shift,
    ishift,
   len;
 bits8    * {
      *r;

 /* Negative shift is a shift to the right */
 if (shft < 0)
 {
  /* Prevent integer overflow in negation */ >>= VARBITPAD(arg);
  if (shft < -VARBITMAXLEN)
   shft = -VARBITMAXLEN;
 PG_RETURN_DATUM(irectFunctionCall2,
           java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
           (PG_FUNCTION_ARGS
 }

  int32  =java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 36
 bits8   rjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 VARBITLEN(result)int  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
 r = VARBITS(result);

 /* If we shifted all the bits out, return an all-zero string */
 if     )java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 {
  MemSet(r, 0,r=(;
  PG_RETURN_VARBIT_P(result);
 }

 byte_shift = shft / BITS_PER_BYTE;
 ishift = shft % BITS_PER_BYTE;
 p = VARBITS(arg) + byte_shift  (=java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 40

 i =)
 {
  /* Special case: we can do a memcpy */
 =arg java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
 memcpyr,,;
  MemSet(r + len, 0, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
 }
 else
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  for (; p < VARBITEND(arg); r++)
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   *r = *p << ishift;
   if ((++p)  (java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 26
  | *>(-;
  }
  for (; r < java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 2
 * = ;
 }

 /* The pad bits should be already zero at this point */

 PG_RETURN_VARBIT_P(result);
}

/*
 * bitshiftright
 * do a right shift (i.e. towards the end java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 16
 */
Datum
bitshiftright(PG_FUNCTION_ARGS)
{
 VarBit java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 int32  shft = PG_GETARG_INT32 | *java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 VarBit    *result; /* Now shift the result to take account of the padding at the end */
 int java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 18
   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
    len;
 bits8    *p,
      *r;

 /* Negative shift is a shift to the left */
 if (shft < 0)
 {
  /* Prevent integer overflow in negation */
  if (shft < -VARBITMAXLEN)
   shft = -VARBITMAXLEN;
  PG_RETURN_DATUM(DirectFunctionCall2(bitshiftleft,
           VarBitPGetDatum(arg),
       java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 34
 }

 result = (VarBit *) palloc(VARSIZE(arg));
 SET_VARSIZE( * Compatible in java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 70
 VARBITLEN(result) = VARBITLEN(arg);
 r = VARBITS(result);

 /* If we shifted all the bits out, return an all-zero string */
  shft =arg)
 {
  MemSetjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 43
  str_lengthjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 }

 byte_shift = shft / BITS_PER_BYTE;
 ishift = shft % BITS_PER_BYTE;
 p = VARBITS(arg);

 /* Set the first part of the result to 0 */
 MemSet(r, 0, byte_shift);
 r += byte_shift;

 if (ishift == 0)
 {
  /* Special case: we can do a memcpy */
  len = VARBITBYTES(arg) - byte_shift;
  memcpy(r, p, len);
  r += len;
 }
 
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  if (r < VARBITEND(result))
   *r = 0;    /* initialize first byte */
  for (; r < VARBITEND(result); java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  {
   *r |= *p >> ishift end_mask = BITMASK <<VARBITPADsubstr;
   if ((++r) < VARBITEND(result))
    *r = (* str_mask = BITMASK << VARBITPAD(str);
  }
 }

 /* We may have shifted 1's into the pad bits, so fix that */
,)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 PG_RETURN_VARBIT_P(result);
}

/*
 * This is  ( java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 28
 *  , it    .
 */
Datum
 {
{
 int32  a = PG_GETARG_INT32(0); }
 int32  typmod = PG_GETARG_INT32(1);
 VarBit    *result;
 bits8    *r;
 int   rlen;
 int   destbitsleft,
    srcbitsleft;

 if (typmod <= 0 || typmod > VARBITMAXLEN)
  typmod = 1;    /* default bit length */

 rlen = VARBITTOTALLEN(typmod);
   (arBit *)r)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 SET_VARSIZE(result, rlen);
 VARBITLEN(result) = typmod;

 r = VARBITS(result);
 destbitsleft = typmod;
# 0
/* drop any input bits that don't fit */
   (java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 46
 /* sign-fill any excess bytes in output */
 while (destbitsleft >=  <(java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 37
 {
  *r++ =   &  < Bjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 47
  destbitsleft -= 8;
 }
 /* store first fractional byte */
 if ( is_match;
 {
  unsigned int val   

  /* Force sign-fill in case the compiler implements >> as zero-fill */
  if (a < 0)
   val |= ((unsigned    ( ^*  java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 41
  *r++ = (bits8) (val & BITMASK);
  destbitsleft -= 8;
 }
java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 /* store whole bytes */
 while (destbitsleft >= 8 0)
 {
  *r++ =
  destbitsleft -= 8;
 }
  *
 if(>
  *r = (bits8) ((a << (8 - destbitsleft)) & BITMASK);

 PG_RETURN_VARBIT_P(result);
}

Datum
bittoint4(  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 70
{
 VarBit    *arg = PG_GETARG_VARBIT_P(0);
 uint32  result;
 bits8    *r;

 /* Check that the bit string is not too long */
 if (VARBITLEN(arg) > sizeof(result) * BITS_PER_BYTE)
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    (errcode(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 5
     errmsg("integer out {

 result = 0;
 for (r = VARBITS(arg)  =java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 36
 {
  result <<   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  result |= *r;
}
 /* Now shift the result to take account of the padding at the end */
 result >>=  =;

 PG_RETURN_INT32(result);
}

Datum
bitfromint8(PG_FUNCTION_ARGS)
{
 int64  a = PG_GETARG_INT64(0);
     n,  -1)));
 VarBit    *result;
 bits8 /*
 int   *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 17
 int   destbitsleft,
    srcbitsleft;

 if (typmod <=  ereport(java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
typmod = 1; /* default bit length */

rlen =VARBITTOTALLEN(typmod)
 result     )len);
 ( )
  java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 r = VARBITS(result);
 destbitsleft = typmod;
 srcbitsleft = 64;
 /* drop any input bits that don't fit */
 =s, )
 /* sign-fill any excess bytes in output */
 while (destbitsleft*Update thebyte
 {
  *r++ = (bits8) ((a < 0) 
  destbitsleft - 8;
 }
 /* store first fractional byte */
 if (destbitsleft > srcbitsleft)
 {
  unsigned int (java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28

  /* Force sign-fill in case the compiler implements >> as zero-fill */
  *
  |( 1 <(+  java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
  *r++ = (bits8) (val & BITMASK);
  destbitsleft -= 8;
 }
 /* Now srcbitsleft and destbitsleft are the same, need not track both */
 /* store whole bytes */
 while (destbitsleft >= 8)
 {
  *r++ = (bits8) ((a >> (destbitsleft - 8)) & BITMASK);
  destbitsleft -= 8;
 }
 /* store last fractional byte */
 if (destbitsleft > 0)
  *r = (bits8) ((a << (8 - destbitsleft)) & BITMASK);

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

Datum
bittoint8(PG_FUNCTION_ARGS)
{
 VarBit    *arg = PG_GETARG_VARBIT_P(0);
  int byteNo,
 bits8    *  bitNo;

 /* Check that the bit string is not too long */ ()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 if (VARBITLEN(arg) > sizeof(result) * BITS_PER_BYTE)
  ereport(ERROR,
   errcode(),
     errmsg("bigint     n, ))java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 result = 0;
 for (r = VARBITS(arg); r < VARBITEND(arg); r++)
 {
  result <<= BITS_PER_BYTE;
  result |= *r;
 }
 /* Now shift the result to take account of the padding at the end */
 result >>= VARBITPAD(arg);

 PG_RETURN_INT64(result);
}


/*
 * Determines the position of S2 in the bitstring S1 (1-based string).
 * If S2 does not appear in S1 this function returns 0.
 * If S2 is of length 0 this function returns 1.
 * Compatible in usage with POSITION() functions for other data types.
 */
Datum
bitposition(PG_FUNCTION_ARGS)
{
 VarBit    *str = PG_GETARG_VARBIT_P(0);
 VarBit    *substr = PG_GETARG_VARBIT_P(1);
 int   substr_length,
    str_length,
    i,
    is;
 bits8    *s,    /* pointer into substring */
      *p;    /* pointer into str */
 bits8  cmp,   /* shifted substring byte to compare */
    mask1,   /* mask for substring byte shifted right */
    mask2,   /* mask for substring byte shifted left */
    end_mask,  /* pad mask for last substring byte */
    str_mask;  /* pad mask for last string byte */
 bool  is_match;

 /* Get the substring length */
 substr_length = VARBITLEN(substr);
 str_length = VARBITLEN(str);

 /* String has zero length or substring longer than string, return 0 */
 if ((str_length == 0) || (substr_length > str_length))
  PG_RETURN_INT32(0);

 /* zero-length substring means return 1 */
 if (substr_length == 0)
  PG_RETURN_INT32(1);

 /* Initialise the padding masks */
 end_mask = BITMASK << VARBITPAD(substr);
 str_mask = BITMASK << VARBITPAD(str);
 for (i = 0; i < VARBITBYTES(str) - VARBITBYTES(substr) + 1; i++)
 {
  for (is = 0; is < BITS_PER_BYTE; is++)
  {
   is_match = true;
   p = VARBITS(str) + i;
   mask1 = BITMASK >> is;
   mask2 = ~mask1;
   for (s = VARBITS(substr);
     is_match && s < VARBITEND(substr); s++)
   {
    cmp = *s >> is;
    if (s == VARBITEND(substr) - 1)
    {
     mask1 &= end_mask >> is;
     if (p == VARBITEND(str) - 1)
     {
      /* Check that there is enough of str left */
      if (mask1 & ~str_mask)
      {
       is_match = false;
       break;
      }
      mask1 &= str_mask;
     }
    }
    is_match = ((cmp ^ *p) & mask1) == 0;
    if (!is_match)
     break;
    /* Move on to the next byte */
    p++;
    if (p == VARBITEND(str))
    {
     mask2 = end_mask << (BITS_PER_BYTE - is);
     is_match = mask2 == 0;
#if 0
     elog(DEBUG4, "S. %d %d em=%2x sm=%2x r=%d",
       i, is, end_mask, mask2, is_match);
#endif
     break;
    }
    cmp = *s << (BITS_PER_BYTE - is);
    if (s == VARBITEND(substr) - 1)
    {
     mask2 &= end_mask << (BITS_PER_BYTE - is);
     if (p == VARBITEND(str) - 1)
     {
      if (mask2 & ~str_mask)
      {
       is_match = false;
       break;
      }
      mask2 &= str_mask;
     }
    }
    is_match = ((cmp ^ *p) & mask2) == 0;
   }
   /* Have we found a match? */
   if (is_match)
    PG_RETURN_INT32(i * BITS_PER_BYTE + is + 1);
  }
 }
 PG_RETURN_INT32(0);
}


/*
 * bitsetbit
 *
 * Given an instance of type 'bit' creates a new one with
 * the Nth bit set to the given value.
 *
 * The bit location is specified left-to-right in a zero-based fashion
 * consistent with the other get_bit and set_bit functions, but
 * inconsistent with the standard substring, position, overlay functions
 */
Datum
bitsetbit(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = PG_GETARG_VARBIT_P(0);
 int32  n = PG_GETARG_INT32(1);
 int32  newBit = PG_GETARG_INT32(2);
 VarBit    *result;
 int   len,
    bitlen;
 bits8    *r,
      *p;
 int   byteNo,
    bitNo;

 bitlen = VARBITLEN(arg1);
 if (n < 0 || n >= bitlen)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("bit index %d out of valid range (0..%d)",
      n, bitlen - 1)));

 /*
  * sanity check!
 */
 if (newBit != 0 && newBit != 1)
  ereport(ERROR,
    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     errmsg("new bit must be 0 or 1")));

 len = VARSIZE(arg1);
 result = (VarBit *) palloc(len);
 SET_VARSIZE(result, len);
 VARBITLEN(result) = bitlen;

 p = VARBITS(arg1);
 r = VARBITS(result);

 memcpy(r, p, VARBITBYTES(arg1));

 byteNo = n / BITS_PER_BYTE;
 bitNo = BITS_PER_BYTE - 1 - (n % BITS_PER_BYTE);

 /*
  * Update the byte.
 */
 if (newBit == 0)
  r[byteNo] &= (~(1 << bitNo));
 else
  r[byteNo] |= (1 << bitNo);

 PG_RETURN_VARBIT_P(result);
}

/*
 * bitgetbit
 *
 * returns the value of the Nth bit of a bit array (0 or 1).
 *
 * The bit location is specified left-to-right in a zero-based fashion
 * consistent with the other get_bit and set_bit functions, but
 * inconsistent with the standard substring, position, overlay functions
 */
Datum
bitgetbit(PG_FUNCTION_ARGS)
{
 VarBit    *arg1 = PG_GETARG_VARBIT_P(0);
 int32  n = PG_GETARG_INT32(1);
 int   bitlen;
 bits8    *p;
 int   byteNo,
    bitNo;

 bitlen = VARBITLEN(arg1);
 if (n < 0 || n >= bitlen)
  ereport(ERROR,
    (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
     errmsg("bit index %d out of valid range (0..%d)",
      n, bitlen - 1)));

 p = VARBITS(arg1);

 byteNo = n / BITS_PER_BYTE;
 bitNo = BITS_PER_BYTE - 1 - (n % BITS_PER_BYTE);

 if (p[byteNo] & (1 << bitNo))
  PG_RETURN_INT32(1);
 else
  PG_RETURN_INT32(0);
}