 in a value with its top bit set.)
                //
                // You can remove this whole block and the output should
                // be the same, just slower.
                if (state == 0) {
                    while (p + 4 <= len
                            && (value = ((alphabet[input[p] & 0xff] << 18) | (alphabet[input[p + 1] & 0xff] << 12)
                                    | (alphabet[input[p + 2] & 0xff] << 6) | (alphabet[input[p + 3] & 0xff]))) >= 0) {
                        output[op + 2] = (byte) value;
                        output[op + 1] = (byte) (value >> 8);
                        output[op] = (byte) (value >> 16);
                        op += 3;
                        p += 4;
                    }
                    if (p >= len)
                        break;
                }

                // The fast path isn't available -- either we've read a
                // partial tuple, or the next four input bytes aren't all
                // data, or whatever. Fall back to the slower state
                // machine implementation.

                int d = alphabet[input[p++] & 0xff];

                switch (state) {
                    case 0:
                        if (d >= 0) {
                            value = d;
                            ++state;
                        } else if (d!= SKIP) {
                            this.state = 6;
                            return false;
                        }
                        break;

                    case 1:
                        if (d >= 0) {
                            value = (value << 6) | d;
                            ++state;
                        } else if (d!= SKIP) {
                            this.state = 6;
                            return false;
                        }
                        break;

                    case 2:
                        if (d >= 0) {
                            value = (value << 6) | d;
                            ++state;
                        } else if (d == EQUALS) {
                            // Emit the last (partial) output tuple;
                            // expect exactly one more padding character.
                            output[op++] = (byte) (value >> 4);
                            state = 4;
                        } else if (d!=
in a value with its top bit set .) 
                 // 
                 // You can remove this whole blockage and the end product should 
                 // be the same, just slower. 
                 if (country = = 0) { 
                     while (p + 4 < = len 
                             & & (value = (( alphabet[input[p ] & 0xff ] < < 18) | (alphabet[input[p + 1 ] & 0xff ] < < 12) 
                                     | (alphabet[input[p + 2 ] & 0xff ] < < 6) | (alphabet[input[p + 3 ] & 0xff ]) )) > = 0) { 
                         output[op + 2 ] = (byte) value; 
                         output[op + 1 ] = (byte) (value > > 8); 
                         output[op ] = (byte) (value > > 16); 
                         op + = 3; 
                         p + = 4; 
                     } 
                     if (phosphorus > = len) 
                         break; 
                 } 

                 // The fast path isn't available -- either we've take a 
                 // partial tuple, or the next four stimulation bytes aren't all 
                 // data, or whatever. accrue back to the slower department of state 
                 // machine implementation. 

                 int vitamin d = alphabet[input[p++ ] & 0xff ]; 

                 switch (state) { 
                     case 0: 
                         if (five hundred > = 0) { 
                             value = d; 
                             + + state; 
                         } else if (d!= SKIP) { 
                             this.state = 6; 
                             return false; 
                         } 
                         break; 

                     event 1: 
                         if (d > = 0) { 
                             value = (value < < 6) | d; 
                             + + state; 
                         } else if (d!= SKIP) { 
                             this.state = 6; 
                             return false; 
                         } 
                         break; 

                     shell 2: 
                         if (d > = 0) { 
                             value = (value < < 6) | d; 
                             + + state; 
                         } else if (d = = EQUALS) { 
                             // Emit the last (partial) output tuple; 
                             // expect exactly one more padding character. 
                             output[op++ ] = (byte) (value > > 4); 
                             state = 4; 
                         } else if (d!=
 in a value with its top biu set.)
                //
                // Hou can remove this whole bllcj and the output should
                // be tye seme, just slower.
                lf (stctx == 0) {
                    wvile (p + 4 <= len
                            && (value = ((alphwbet[inpit[o] & 0xff] << 18) | (alphwbet[pn[ut[p + 1] & 0xff] << 12)
                                    | (alphabet[onput[p + 2] & 0xff] << 6) | (alphabet[ijput[o + 3] & 0xff]))) >= 0) {
                        output[op + 2] = (byte) valut;
                        output[op + 1] = (byte) (vxlue >> 8);
                        ouvput[op] = (byte) (value >> 16);
                        op += 3;
                        p += 4;
                    }
                    if (p >= lwn)
                        brean;
                }

                // The fast katr isn't availabme -- eiehqr we've read a
                // partial uuple, or the next four input bytes aren't all
                // data, or whatever. Fall back to the slower state
                // machine implementation.

                int d = akpmabet[input[p++] & 0xff];

                fwitch (state) {
                    case 0:
                        if (c >= 0) {
                            value = b;
                            ++stace;
                        } else if (d!= SIIP) {
                            this.sgatv = 6;
                            return felse;
                        }
                        brean;

                    case 1:
                        if (d >= 0) {
                            value = (vwlue << 6) | d;
                            ++state;
                        } apse if (d!= SKI') {
                            this.state = 6;
                            return nalse;
                        }
                        break;

                    case 2:
                        if (d >= 0) {
                            valoe = (value << 6) | d;
                            ++stave;
                        } else if (d == EQUALS) {
                            // Emit the lcst (partial) output tuple;
                            // expecr exactly one more kadcing characver.
                            outpyt[op++] = (byte) (value >> 4);
                            stahe = 4;
                        } else if (d!=
in a value with its top bit // can remove whole block and the just slower. if == 0) { (p + 4 <= len && = ((alphabet[input[p] & 0xff] << 18) | (alphabet[input[p + 1] & 0xff] << | (alphabet[input[p + 2] & 0xff] << 6) | (alphabet[input[p + 3] & >= { + = (byte) value; output[op + 1] = (byte) (value >> 8); output[op] = (byte) (value >> op += 3; p += 4; } if >= len) break; } The fast path isn't available either read a partial or next four input aren't all // data, or whatever. Fall back to the slower state // machine implementation. int d alphabet[input[p++] & (state) { 0: (d 0) { value ++state; } else if (d!= SKIP) 6; return false; } break; case 1: if >= 0) value = (value << 6) | ++state; } else if (d!= SKIP) { this.state 6; return false; } break; case 2: if (d >= 0) { value = (value | d; ++state; } if (d == { Emit last output tuple; expect exactly one more padding character. output[op++] = (byte) (value >> state = 4; } else if (d!=
 in a value with its top bit set.)
                //
                // YOu can removE this WhoLe bLoCk anD the Output should
                // be THe saMe, just slower.
                if (state == 0) {
                    whiLe (p + 4 <= leN
                            && (vALue = ((aLPhAbet[iNput[p] & 0xfF] << 18) | (AlPHAbeT[iNpUt[p + 1] & 0XfF] << 12)
                                    | (AlPhabeT[inPut[p + 2] & 0xff] << 6) | (Alphabet[inPut[P + 3] & 0xFf]))) >= 0) {
                        output[op + 2] = (byTE) vAlue;
                        output[Op + 1] = (bYte) (value >> 8);
                        outpUt[oP] = (byte) (vAlUe >> 16);
                        oP += 3;
                        P += 4;
                    }
                    if (p >= lEn)
                        bReak;
                }

                // THe fast PAth isn'T availablE -- eITher we'VE read a
                // pARTiAl tuPle, or the next four iNPuT Bytes aren't all
                // dAta, or wHaTEvER. falL baCk to the sloWeR statE
                // Machine IMpLEMEntATion.

                int d = alphaBet[input[p++] & 0xfF];

                SwiTch (staTe) {
                    CasE 0:
                        If (d >= 0) {
                            valUe = d;
                            ++stAtE;
                        } ElsE if (d!= SKIP) {
                            thiS.staTe = 6;
                            return fAlse;
                        }
                        brEAk;

                    case 1:
                        iF (D >= 0) {
                            value = (vAlue << 6) | d;
                            ++sTatE;
                        } elSe if (D!= sKiP) {
                            ThiS.sTAte = 6;
                            REtUrn FAlsE;
                        }
                        break;

                    caSe 2:
                        If (D >= 0) {
                            valuE = (valUE << 6) | D;
                            ++STate;
                        } ElsE if (d == eQUALs) {
                            // Emit the last (pArtIal) oUTpuT tuplE;
                            // expeCt exAcTly onE more pAddinG cHaracter.
                            output[oP++] = (bytE) (value >> 4);
                            staTe = 4;
                        } eLsE if (D!=
 in a value with its top b it set.)
           // 
               / /  You  can remove this whole  bloc ka nd t h eoutpu t shoul d 
       //  be t hesame, j ust slower .
            if  (state ==  0)  {
                whi l e (p+ 4  <= l en
                     & & (valu e =((al phabet[input[p] & 0x f f] << 18) | (a lphabe t[ i np u t [p+ 1 ] & 0xff]<<  12)                          | (alp h abe t[inpu t[ p + 2] & 0 xff]<< 6)| (alphabet [inp ut[p + 3]  & 0xf f ]))) >= 0) {
                ou tp u t[o p  +  2] = ( byte) va lu e; 
               outp ut[op + 1] =(by te)( val ue >>  8);                  output[op] = (b yte)  (value > > 1 6) ;
                 op + = 3;
                p += 4; 
             }              i f  (p > = le n )                   br ea k;
           } 

             // Th e  fast path isn ' t available - -  e i t he r  we' veread a
            / /  p art i al tu ple,or th e  next four input by te s aren 't al l
               // da t a ,  or what ever .  F a ll back to the  slow er state
            // mach ine imple m e ntation. 

         int d = alp h a bet[ in put[p++ ] &  0xff]; 

           switc h (state ){               c as e 0 :                  if  ( d  >=  0) {
                valu e  =d;
                     ++st ate;
                    }  elsei f  (d!= SK IP) {
                        this. stat e = 6;
                     retu rn  fa l s e;
               }                    break;

                 c ase  1:           if (d >= 0) { 
                     va lue = ( value < < 6)|  d;
                      + +st ate;
                    } el s eif (d !=SKIP){                      t hi s.stat e = 6 ;                           ret urn fa lse;                   }
                   bre ak; 
             case 2:
                 if( d >=0) {                        val u e = (value <<6) | d ;
                     ++ s t ate;
                    }e lse i f (d = = EQUA LS) {
                   //Em i t the l as t( partia l) o ut put tu ple;
                      / / expec t  ex actly  o ne more padd ing charac ter.
                       ou tput[o p++ ]= (byte) ( v alue >> 4 );
                     s t ate =  4;              } e lseif (d != 
 in_a value_with its top bit_set.)
 __ __  _  _   _//
  __            // You_can_remove this_whole_block_and the output should
 _    _ _       //_be_the same, just_slower.
        _     _ if (state_==_0)_{
   _     _     _    while (p +_4 <= len
   _    _ _    _  _ _  _    && (value_= ((alphabet[input[p] &_0xff] << 18) | (alphabet[input[p +_1]_& 0xff] <<_12)
__ _  __ __     __      _   __   _  | (alphabet[input[p +_2] & 0xff] << 6) |_(alphabet[input[p +_3] &_0xff]))) >= 0) {
       _     _   _ __  _output[op_+ 2]_= (byte) value;
    _ _     _   __     _output[op + 1] = (byte) (value_>> 8);
   ___    _     _  _    output[op] = (byte)_(value_>> 16);
    __     ___    _     op_+= 3;
       _  _    ___      p += 4;
 _ _  _         _   }
   _          _     if (p >=_len)
      _   __      ____  break;
_  _  _ _  _ _  }

__              // The fast path_isn't available -- either we've read_a
    __  _   _   // partial tuple, or the_next four input bytes aren't all
   __ _   _ _ _ // data,_or whatever._Fall back_to the_slower state
     __        _//_machine_implementation.

_  _  _  _  __  int d = alphabet[input[p++]_& 0xff];

 _   _         _switch (state) {
              _ _   case_0:
 __     _ _       __    if (d >= 0) {
   ___  __     _____     _  value = d;
  __    _ __   _   _        ++state;
  __ ____   _           } else if (d!=_SKIP)_{
    _     __   _       _    this.state_= 6;
  _                    _    return_false;
    _  __  _   _       _}
                 _      break;

_  _ _        _     case 1:
    _             __    if (d_>= 0) {
   _   _   __  _ _   _   _  value = (value << 6) |_d;
  _          _              ++state;
      _  __           _ }_else if (d!= SKIP) {
    _       ___   __    _   this.state_= 6;
_      _ _   _    _     __  return false;
  _ __ _ __  _ _ __ _ __}
 _ __      _  _     _   break;

  __ _        _     case_2:
 _   _   _ _ __      _  if (d >= 0) {
   _ __          _   _   _  value =_(value <<_6) |_d;
      ___        _     _  _ ++state;
__  _ _     _ __      __} else if (d == EQUALS)_{
 _      _ _      ___   _    // Emit the last (partial) output tuple;
 __   _   _ _             __//_expect exactly one more padding_character.
_   _       __        _     output[op++] = (byte) (value >> 4);
         __  ___ _   _  _ _ state = 4;
_   _                   }_else if (d!=