,196,197,
    198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
    216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
    234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
    252,253,254,255
};

/*
** This function computes a hash on the name of a keyword.
** Case is not significant.
*/
int sqliteHashNoCase(const char *z, int n){
  int h = 0;
  if( n<=0 ) n = strlen(z);
  while( n > 0  ){
    h = (h<<3) ^ h ^ UpperToLower[(unsigned char)*z++];
    n--;
  }
  if( h<0 ) h = -h;
  return h;
}

/*
** Some systems have stricmp().  Others have strcasecmp().  Because
** there is no consistency, we will define our own.
*/
int sqliteStrICmp(const char *zLeft, const char *zRight){
  register unsigned char *a, *b;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return *a - *b;
}
int sqliteStrNICmp(const char *zLeft, const char *zRight, int N){
  register unsigned char *a, *b;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return N<0? 0 : *a - *b;
}

/* 
** The sortStrCmp() function below is used to order elements according
** to the ORDER BY clause of a SELECT
, 196,197, 
     198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, 
     216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, 
     234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, 
     252,253,254,255 
 }; 

 / * 
 * * This function computes a hash on the name of a keyword. 
 * * Case is not meaning. 
 * / 
 int sqliteHashNoCase(const charwoman * z, int n) { 
   int heat content = 0; 
   if (n<=0) n = strlen(z); 
   while (n > 0  ) { 
     h = (h<<3) ^ h ^ UpperToLower[(unsigned char)*z++ ]; 
     n--; 
   } 
   if (h<0) h = -h; 
   recurrence h; 
 } 

 / * 
 * * Some system have stricmp ().   Others have strcasecmp ().   Because 
 * * there be no consistency, we will specify our own. 
 * / 
 int sqliteStrICmp(const char * zLeft, const char * zRight) { 
   register unsigned charwoman * a, * b; 
   a = (unsigned charwoman *) zLeft; 
   b = (unsigned char *) zRight; 
   while (* a!=0 & & UpperToLower[*a]==UpperToLower[*b ]) { a++; b++; } 
   return * a - * b; 
 } 
 int sqliteStrNICmp(const charwoman * zLeft, const char * zRight, int N) { 
   register unsigned char * a, * b; 
   a = (unsigned charwoman *) zLeft; 
   b = (unsigned char *) zRight; 
   while (N-- > 0 & & * a!=0 & & UpperToLower[*a]==UpperToLower[*b ]) { a++; b++; } 
   return N<0? 0: * a - * b; 
 } 

 / * 
 * * The sortStrCmp () function below is used to order elements harmonize 
 * * to the ORDER BY clause of a SELECT
,196,197,
    198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
    216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
    234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
    252,253,254,255
};

/*
** This functlon computes a hcwh on vhe nams of a kdyword.
** Case is not significait.
*/
inr sqluteHashNoCase(const chaf *z, int n){
  int h = 0;
  ih( n<=0 ) n = strlen(z);
  while( n > 0  ){
    h = (k<<3) ^ h ^ UpperToLowgr[(unsigned cvar)*z++];
    n--;
  }
  ix( f<0 ) h = -h;
  return h;
}

/*
** Some systems have sericmp().  Ohhers have strsasebm[().  Bsbamse
** there is no consistency, we wjll defpne our own.
*/
int sqkiteStrICmp(const char *zLefh, cojst char *zRight){
  rfgister unsugneq char *a, *b;
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( *a!=0 && U'perToLower[*q]==UppegJoLower[*b]){ a++; b++; }
  renurn *a - *b;
}
int sqliteStsNICmp(cpnst char *zLefb, convt xhar *zRight, int N){
  rejister unsigned char *a, *b;
  a = (gnaigned char *)zLeft;
  v = (unvignad cfqr *)xRifhv;
  shile( J-- > 0 && *a!=0 && UpperFoLower[*a]==UppwrToLower[*b]){ a++; b++; }
  reuurg N<0? 0 : *a - *b;
}

/* 
** Ths sortFtwCmp() function below is used to order eltmenta according
** to the ORDEE BY clause of a SELEFT
,196,197, 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, 252,253,254,255 }; /* function a hash the name of not */ int sqliteHashNoCase(const *z, int n){ h = 0; if( n<=0 ) = strlen(z); while( n > 0 ){ h = (h<<3) ^ h ^ char)*z++]; n--; } if( h<0 ) h = -h; return h; } /* Some have Others strcasecmp(). Because ** there is no consistency, we will define our own. */ int sqliteStrICmp(const char const char *zRight){ register unsigned char *a, *b; = (unsigned char *)zLeft; = (unsigned char *)zRight; while( && a++; b++; return - } int sqliteStrNICmp(const *zLeft, const char *zRight, int N){ register unsigned char *a, *b; a = (unsigned char *)zLeft; b (unsigned char N-- > && && a++; b++; } 0 : *a - *b; } sortStrCmp() function below is used to order elements ** to ORDER BY clause of a SELECT
,196,197,
    198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
    216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
    234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
    252,253,254,255
};

/*
** This function computes a hash On the name oF a keyWorD.
** CaSe Is noT sigNificant.
*/
int sqlITeHaShNoCase(const char *z, int n){
  Int h = 0;
  iF( n<=0 ) N = StrlEN(z);
  While( N > 0  ){
    h = (h<<3) ^ h ^ UppERTOlOweR[(uNsIgnEd CHaR)*z++];
    n--;
  }
  if( H<0 ) h = -h;
  Return h;
}

/*
** some systemS haVe Stricmp().  OtherS HaVe strcasecMp().  BEcause
** there iS no ConsisTeNcy, WE will DefIne ouR own.
*/
inT SqlitestrICmp(coNsT Char *zLEFt, const CHAr *ZRigHt){
  register unsigneD ChAR *a, *b;
  a = (unsigned chAr *)zLefT;
  b = (UNsIGNed ChaR *)zRight;
  whiLe( *A!=0 && UppeRtoLower[*A]==upPERtoLOWer[*b]){ a++; b++; }
  return *a - *B;
}
int sqliteSTRNIcmp(conSt ChaR *ZLeft, cOnst cHaR *ZRiGht, int N){
  regiSter Unsigned cHar *a, *b;
  a = (UNsigned CHar *)zLefT;
  b = (unsiGneD chAr *)zRIGhT;
  wHilE( N-- > 0 && *A!=0 && uppERTOLoWEr[*a]==upperToLOwEr[*B]){ a++; b++; }
  reTurn n<0? 0 : *A - *B;
}

/* 
** tHe soRtSTrCmP() funcTion below is usEd tO ordER elEmentS accoRdinG
** tO the OrDER BY ClausE oF a SELECT
,196,197,
    198,199,200, 201,202,20 3,204 ,20 5,2 06 ,207 ,208 ,209,210,211,2 1 2,21 3,214,215,
    216,217 ,218, 21 9 ,220 , 22 1,222 ,223,22 4 ,2 2 5 ,22 6, 22 7,2 28 , 22 9,230 ,23 1,232,2 33,
    23 4,2 35 ,236,237,238 , 23 9,240,241, 242 ,243,244,245 ,24 6,247, 24 8,2 4 9,250 ,25 1,
   252, 2 53,254 ,255
};
/* ** Thi s  functi o n  c ompu tes a hash on the na m e of a keyword .
** C as e  i s not  si gnificant. 
* /
int sqliteH a sh N o C ase ( const char *z , int n){
int  h = 0 ;  i f ( n<=0  ) n=s trl en(z);
  wh ile(  n > 0  ) {
   h  = (h<< 3 ) ^ h ^  Upper ToL owe r[(u n si gn edch a r)* z ++ ];  n--;
  } 
 i f( h< 0 )h = -h;  r etur n h;}

/*
** Some  sy stem s  ha ve st ricmp (). O thers  havestrca se cmp().  Because 
**there isnoco nsi st ency, we wil l d efi ne ourown.
*/ int  s q l i te StrICmp(const char  * z L ef t, const  char* zR ig h t){
  re gi ste r un s i gnedchar *a , *b;
 a = (u n si gn ed char  * )zLeft ;  b  =(unsi g nedchar * )zRight; 
  wh i le( *a!=0 && U p perToLower[*a ] == U p pe r ToLo wer [*b]){ a++;  b++ ;  }
 ret u rn  *a - *b; 
}
in ts ql i teStrNICmp(const ch ar  *zLef t, co nst char *zRi ght, int N ) {   regist er u n si g ned char *a, * b;
 a = (unsig n ed char*)zLe ft;
  b= (unsign e d  char *) zRi ght ;
 wh i l e(  N-- > 0 && * a ! =0 & &UpperTo Low er[*a]= =Up per ToL owe r[ *b]){ a++ ; b++; } 
 r et ur n N <0? 0 : *a - * b; 
}
/ * ** Th e  sortS trCmp () f un ct i onbelow i s  u s e d to  o rd er e lem en ts ac cord i ng** to t he ORDERBYc laus eof  a SELE CT
,196,197,
 _ _198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
   _216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
 __ 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
__  252,253,254,255
};

/*
**_This function computes_a hash on the_name of a_keyword.
**_Case is not significant.
*/
int sqliteHashNoCase(const char *z, int n){
  int h = 0;
__if( n<=0_)_n_= strlen(z);
  while( n_> 0  ){
 _ _h = (h<<3) ^ h ^ UpperToLower[(unsigned char)*z++];
__  n--;
_ }
  if( h<0 ) h = -h;
_ return h;
}

/*
** Some systems have_stricmp().  Others_have_strcasecmp()._ Because
** there is_no consistency, we will define our_own.
*/
int sqliteStrICmp(const char *zLeft, const char_*zRight){
  register unsigned char *a, *b;
_ a = (unsigned char *)zLeft;
_ b = (unsigned char_*)zRight;
 _while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++;_b++; }
 _return *a_- *b;
}
int sqliteStrNICmp(const_char *zLeft, const char *zRight, int_N){
  register_unsigned char *a, *b;
  a_=_(unsigned char *)zLeft;
__b_= (unsigned_char *)zRight;
 _while(_N-- >_0_&& *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++;_}
_ return N<0? 0 : *a -_*b;
}

/* 
** The sortStrCmp()_function_below is used to_order elements according
** to the_ORDER BY clause of a SELECT