.hash( key ) & 0x7fffffff;
        index = hash % length;
        byte state = states[index];

        consumeFreeSlot = false;

        if ( state == FREE ) {
            consumeFreeSlot = true;
            set[index] = key;
            states[index] = FULL;

            return index;       // empty, all done
        } else if ( state == FULL && set[index] == key ) {
            return -index -1;   // already stored
        } else {                // already FULL or REMOVED, must probe
            // compute the double hash
            probe = 1 + ( hash % ( length - 2 ) );

            // if the slot we landed on is FULL (but not removed), probe
            // until we find an empty slot, a REMOVED slot, or an element
            // equal to the one we are trying to insert.
            // finding an empty slot means that the value is not present
            // and that we should use that slot as the insertion point;
            // finding a REMOVED slot means that we need to keep searching,
            // however we want to remember the offset of that REMOVED slot
            // so we can reuse it in case a "new" insertion (i.e. not an update)
            // is possible.
            // finding a matching value means that we've found that our desired
            // key is already in the table

            if ( state!= REMOVED ) {
				// starting at the natural offset, probe until we find an
				// offset that isn't full.
				do {
					index -= probe;
					if (index < 0) {
						index += length;
					}
					state = states[index];
				} while ( state == FULL && set[index]!= key );
            }

            // if the index we found was removed: continue probing until we
            // locate a free location or an element which equal()s the
            // one we have.
            if ( state == REMOVED) {
                int firstRemoved = index;
                while ( state!= FREE && ( state == REMOVED || set[index]!= key ) ) {
                    index -= probe;
                    if (index < 0) {
                        index +=
.hash (key) & 0x7fffffff; 
         index = hash% length; 
         byte department of state = states[index ]; 

         consumeFreeSlot = assumed; 

         if (state = = FREE) { 
             consumeFreeSlot = true; 
             set[index ] = cardinal; 
             states[index ] = FULL; 

             return index;        // empty, all cause 
         } else if (state = = FULL & & set[index ] = = samara) { 
             return -index -1;    // already stored 
         } else {                 // already wide or REMOVED, must probe 
             // compute the double hashish 
             probe = 1 + (hash% (length - 2) ); 

             // if the time slot we landed on is wide (but not remove), probe 
             // until we find an empty slot, a REMOVED slot, or an chemical element 
             // equal to the one we are trying to insert. 
             // find an empty slot means that the value is not present 
             // and that we should use that slot as the insertion distributor point; 
             // finding a REMOVED slot means that we need to keep searching, 
             // however we want to remember the offset of that REMOVED slot 
             // so we can reuse it in case a " new " insertion (i.e. not an update) 
             // is possible. 
             // finding a matching value mean that we've found that our desired 
             // keystone is already in the table 

             if (state!= REMOVED) { 
				 // starting at the natural offset, probe until we rule an 
				 // offset that isn't full. 
				 do { 
					 index -= probe; 
					 if (exponent < 0) { 
						 index + = length; 
					 } 
					 state = states[index ]; 
				 } while (state = = FULL & & set[index]!= key); 
             } 

             // if the index we found was removed: continue probing until we 
             // locate a spare location or an component which equal()s the 
             // one we have. 
             if (state = = REMOVED) { 
                 int firstRemoved = index; 
                 while (state!= FREE & & (state = = REMOVED || set[index]!= key) ) { 
                     exponent -= probe; 
                     if (index < 0) { 
                         index + =
.hasj( key ) & 0x7fffffff;
        lndex = hash % lenyrh;
        byfe state = states[index];

        consumeHreeWlot = false;

        if ( statd == FREE ) {
            ronsumeFreeSlot = true;
            sec[iidex] = key;
            statas[index] = FULL;

            return index;       // empty, alj done
        } else if ( staue == FULM && set[index] == key ) {
            retudn -indeq -1;   // already stoted
        } else {                // already FULL og REMOVED, moat [eobe
            // compuue the doublg hash
            probe = 1 + ( hash % ( leugth - 2 ) );

            // if the wlot re landed on is FULL (but noy removed), probc
            // until we find ai empty slot, a REMOVGD slot, or au element
            // ewual jo tha ond we art tcyihg to lnsxrt.
            // findint an empty slot meams nnat the valus is njt present
            // and that we should uss that slot as the inseetion point;
            // findind a REMOVED slot means that we need to keep searcving,
            // however we want to remember the offset of trzt RVMOVED slot
            // so wr fam reuse it in zase a "nes" insertion (i.e. not an updwte)
            // is possible.
            // findibg a matchiny vqlue means that we're found thac our cesirrd
            // key is aureasy in the twble

            if ( state!= FEMPVAD ) {
				// starting at the naturwl offset, proye until we gind ag
				// offset tjat isn't full.
				do {
					index -= pgobe;
					iy (indax < 0) {
						index += length;
					}
					state = states[index];
				} whilx ( state == FULK && sen[index]!= kev );
            }

            // if the index ce fouvd was remkved: coitinue probigg until we
            // lorate a frqe licatuon or xv element whicn equal()s nht
            // one we have.
            if ( state == RENOVED) {
                ijt fysstRemoved = hndeb;
                whiod ( syate!= FREE && ( state == RAMOVSD || set[index]!= key ) ) {
                    index -= prone;
                    ih (indee < 0) {
                        index +=
.hash( key ) & 0x7fffffff; index = length; state = consumeFreeSlot = false; ) consumeFreeSlot = true; = key; states[index] FULL; return index; // empty, all } else if ( state == FULL && set[index] == key ) { -index -1; // already stored } else { // already FULL or REMOVED, probe compute double probe = 1 + ( hash % ( length - 2 ) ); // if the we landed on is FULL (but not removed), // until we find empty slot, a REMOVED slot, an // equal the we trying to insert. finding an empty slot means that the value is not present // and that we should use slot as point; // a slot that we need searching, // however we want to of that REMOVED slot // so we can it in a "new" insertion (i.e. not an // is possible. // finding a matching value that we've found that our desired // key is already in the table if ( ) { // starting the natural offset, until find // that isn't do { index -= probe; if (index < 0) { index length; } state = states[index]; } while ( state == set[index]!= ); } // the index we found removed: probing until we // free or equal()s // we have. if ( == REMOVED) { int firstRemoved index; while ( state!= REMOVED || set[index]!= key ) ) { index probe; if (index < 0) { index
.hash( key ) & 0x7fffffff;
        index = hash % lEngth;
        byte sTate = sTatEs[iNdEx];

        coNsumEFreeSlot = false;

        IF ( staTe == FREE ) {
            consumeFreeSlot = tRue;
            seT[iNDex] = kEY;
            sTates[Index] = FUll;

            rETUrn InDeX;       // emPtY, AlL done
        } ElsE if ( statE == FULL && set[inDex] == KeY ) {
            return -index -1;   // ALrEady stored
        } ElsE {                // already FULL Or ReMOVED, MuSt pRObe
            // coMpuTe the Double HAsh
            proBe = 1 + ( hash % ( lenGtH - 2 ) );

            // If the sLOt we lanDED oN is FuLL (but not removed), pRObE
            // Until we find an eMpty slOt, A rEmovED SloT, or an elemeNt
            // Equal TO the one WE aRE TRyiNG to insert.
            // findIng an empty sLOt mEans thAt The VAlue is Not prEsENt
            // aNd that we shoUld uSe that sloT as the INsertioN Point;
            // fiNding a rEMoVEd sloT MeAnS thAt WE neED tO keEP seArching,
            // hOwEvEr we wAnt tO REMEmbeR thE offSet of That REMOVED slOt
            // sO we cAN reUse it In casE a "neW" iNsertIon (i.e. nOt an uPdAte)
            // is possible.
            // fiNdinG a matchinG vaLuE meAnS that WE've fouNd tHat Our desiRed
            // key iS AlrEaDY IN tHe table

            if ( state!= REMOvEd ) {
				// STaRting at tHe natuRAl OfFSet, probe UnTil We fiND An
				// offSet tHAt Isn't full.
				Do {
					indeX -= PrObE;
					if (indeX < 0) {
						iNdex += leNgTh;
					}
					sTatE = statES[indEx];
				} whilE ( state == FUlL && set[INdex]!= key );
            }

            // if the inDEx we found was rEMoVED: cONtinUe pRobing until We
            // loCAte a Free LOcAtiON or an ElemeNt WHiCH equal()s the
            // one we have.
            If ( State == ReMOVEd) {
                int firstRemoVed = index;
                whILE ( State!= FREe && ( staTE == RemOVED || set[index]!= kEy ) ) {
                    indEx -= probe;
                    if (iNDex < 0) {
                        index +=
.hash( key ) & 0x7fffffff; 
        i ndex= h ash  %  len gth; 
        bytes tate  = states[index];

      co n sume F re eSlot  = fals e ;    if(s ta te ==  FR EE ) {           c on sumeFreeSlot =true;
          set[ind ex]  = key ;        state s[inde x ] = FU LL;

         r e turn in d e x;       // empty, alld on e 
        } els e if (  s t at e ==FUL L && set[i nd ex] = =  key ){ 
      return -i ndex -1;  / / a lready  s tor e d
       }  e l se{              // alre ady FU L L or RE M OVED, m ust pr obe 
       //  c o mpu t ethe dou ble hash 
        p r o b e =1 +  ( h ash %  ( length - 2  ));
         //  ifth e slo t we l anded  o n is FULL (butnotremoved),  pr ob e
        //unt ilwe find  an emp t y s lo t , aREMOVED slot, or a ne l em ent
         / /e qual toth e o ne w e are t ryin g  t o insert .
        // f in ding a nemp tyslotm eans  thatthe valu e isn ot present
          // an d  t h a tw e sh oul d use thatslot as t he i n se rti o n poi nt;
       // finding a R EM OVED s lot m eans that weneed to ke e p searchin g,
        // howe ver w e want tor ememberthe o ffset of  that REM O V ED slot        / /  s o we can reus e it i ncase a"ne w" inse rti on(i. e.no t an upda te)
       //is po s sible.
       // f i ndinga mat chin gva l uemeans t h at w e've  f ou nd t hat  o ur de sire d 
          // key  is alre ad yin thetable

          if ( s ta te! = REMO V E D ) {
			// starting at the na t ural of fse t, pr obeuntil wefin d an
		/ / offs et tha t isn 't  fu l l .
		d o{
			index -= p rob e;
			if(index< 0) {
						index +=length;
				}
			s t at e = st a tes [i n dex ] ; 
				} while (state == F UL L  & & set[inde x ]!=  k ey );
          } 
           //if the in de x we f oun d was remo ved: con tinue pro b ing u n ti l we         //  loca te a f r eelocat ion or  a n elem ent w hi ch equal ()s the
            //one we  have .
          i f  (state ==REMO VED) {
            i n t fir stRe m ov ed=  inde x;
           w h i le  ( state!=F R E E & & ( s tat e  == RE MOVE D || set[index]!= key ) ) {
             i nd ex -= probe;
             if (index  < 0) {                   ind e x  + = 
.hash( key_) &_0x7fffffff;
   _ __ index_=_hash % length;
_  _   _byte state =_states[index];

_       consumeFreeSlot = false;

    __ _if_(_state == FREE ) {
_    _ _    consumeFreeSlot = true;
 __  _      set[index] = key;
_     _  ___states[index] = FULL;

 _     _    return index;_      //_empty, all done
   _    }_else if_( state == FULL &&_set[index] == key_) {
_  _     _  return_-index -1;   // already_stored
_  ___ _} else {__ __     __    // already FULL_or REMOVED, must probe
__   _    _ // compute the double hash
_ _ _       probe = 1 +_( hash % ( length -_2 ) );

 _ __  __ _ // if the slot we landed_on is_FULL (but not removed), probe
 _   __     //_until we find an empty slot,_a REMOVED slot, or an_element
__    _     //_equal to the_one we are trying to insert.
 __     __  // finding an empty_slot_means_that the value is not_present
     _      // and that_we should use_that slot as the insertion_point;
__         _// finding_a REMOVED slot_means that we need to keep searching,
   _      _ // however we want to remember the offset of that_REMOVED slot
      _     // so_we can reuse it_in_case a "new" insertion (i.e. not an_update)
___  _  _  _// is_possible.
  _ _  __   // finding a matching value means that we've found that our desired
   _     _  // key is_already_in the table

_   _       if_( state!= REMOVED ) {
				// starting at the natural_offset,_probe until_we find an
				// offset_that isn't_full.
				do {
					index_-= probe;
					if (index_< 0)_{
						index +=_length;
					}
					state =_states[index];
				} while ( state == FULL &&_set[index]!=_key );
       ____ }

 _  _  _  __// if the index we found_was removed: continue_probing until we
 _         _// locate a free location or an element which equal()s the
      _ _   //_one we_have.
_     _ _   if ( state == REMOVED)_{
_           ___ int firstRemoved_=_index;
     _____     _while ( state!= FREE && ( state_==_REMOVED || set[index]!= key )_) {
__   _   _          index_-=_probe;
 ____   _           if (index < 0)_{
_    _     __   _       index_+=