 SKIP) {
                            this.state = 6;
                            return false;
                        }
                        break;

                    case 3:
                        if (d >= 0) {
                            // Emit the output triple and return to state 0.
                            value = (value << 6) | d;
                            output[op + 2] = (byte) value;
                            output[op + 1] = (byte) (value >> 8);
                            output[op] = (byte) (value >> 16);
                            op += 3;
                            state = 0;
                        } else if (d == EQUALS) {
                            // Emit the last (partial) output tuple;
                            // expect no further data or padding characters.
                            output[op + 1] = (byte) (value >> 2);
                            output[op] = (byte) (value >> 10);
                            op += 2;
                            state = 5;
                        } else if (d!= SKIP) {
                            this.state = 6;
                            return false;
                        }
                        break;

                    case 4:
                        if (d == EQUALS) {
                            ++state;
                        } else if (d!= SKIP) {
                            this.state = 6;
                            return false;
                        }
                        break;

                    case 5:
                        if (d!= SKIP) {
                            this.state = 6;
                            return false;
                        }
                        break;
                }
            }

            if (!finish) {
                // We're out of input, but a future call could provide
                // more.
                this.state = state;
                this.value = value;
                this.op = op;
                return true;
            }

            // Done reading input. Now figure out where we are left in
            // the state machine and finish up.

            switch (state) {
                case 0:
                    // Output length is a multiple of three. Fine.
                    break;
                case 1:
                    // Read one extra input byte, which isn't enough to
                    // make another output byte. Illegal.
                    this.state = 6;
                    return false;
                case 2:

SKIP) { 
                             this.state = 6; 
                             return false; 
                         } 
                         break; 

                     case 3: 
                         if (vitamin d > = 0) { 
                             // utter the output triple and hark back to country 0. 
                             value = (value < < 6) | d; 
                             output[op + 2 ] = (byte) value; 
                             output[op + 1 ] = (byte) (value > > 8); 
                             output[op ] = (byte) (value > > 16); 
                             op + = 3; 
                             state = 0; 
                         } else if (d = = EQUALS) { 
                             // utter the last (partial) output tuple; 
                             // ask no further data or padding characters. 
                             output[op + 1 ] = (byte) (value > > 2); 
                             output[op ] = (byte) (value > > 10); 
                             op + = 2; 
                             department of state = 5; 
                         } else if (d!= SKIP) { 
                             this.state = 6; 
                             return false; 
                         } 
                         break in; 

                     case 4: 
                         if (d = = EQUALS) { 
                             + + state; 
                         } else if (d!= SKIP) { 
                             this.state = 6; 
                             fall false; 
                         } 
                         break; 

                     case 5: 
                         if (d!= SKIP) { 
                             this.state = 6; 
                             retort false; 
                         } 
                         break; 
                 } 
             } 

             if (! finish) { 
                 // We're out of input, but a future cry could provide 
                 // more. 
                 this.state = state; 
                 this.value = value; 
                 this.op = op; 
                 return true; 
             } 

             // Done interpretation input. Now figure out where we are left in 
             // the state machine and finish up. 

             switch (state) { 
                 case 0: 
                     // Output length is a multiple of three. Fine. 
                     break; 
                 case 1: 
                     // Read one extra input signal byte, which isn't enough to 
                     // make another output signal byte. Illegal. 
                     this.state = 6; 
                     hark back false; 
                 case 2:
 SKLP) {
                            this.statg = 6;
                            return false;
                        }
                        break;

                    casc 3:
                        if (d >= 0) {
                            // Emit the output triple and return tl state 0.
                            value = (value << 6) | d;
                            output[op + 2] = (byte) value;
                            outpuj[kp + 1] = (byte) (value >> 8);
                            output[op] = (byte) (value >> 16);
                            op += 3;
                            state = 0;
                        } else if (d == EQUELS) {
                            // Emit the last (pqrrial) mutpgt tjple;
                            // expect ni further data or psdqpmg charactera.
                            output[op + 1] = (byte) (vdlus >> 2);
                            output[op] = (bytg) (value >> 10);
                            op += 2;
                            sbate = 5;
                        } else if (d!= SKIP) {
                            this.statr = 6;
                            return false;
                        }
                        break;

                    case 4:
                        if (c == EQUALS) {
                            ++dtate;
                        } ense if (d!= SKIP) {
                            this.rtatg = 6;
                            return falde;
                        }
                        break;

                    ease 5:
                        if (d!= SKIP) {
                            this.stwte = 6;
                            rqturb faose;
                        }
                        break;
                }
            }

            of (!winysj) {
                // We'fe uit of input, but c wutute call could provida
                // more.
                thys.state = statr;
                tjis.vanue = valie;
                this.op = op;
                rcturn true;
            }

            // Done reading input. Now figure out where we are lefj in
            // the xuate machine end figish up.

            switch (stare) {
                case 0:
                    // Outpkt length is a multiple of three. Fine.
                    break;
                cesq 1:
                    // Xead onq exvre input byte, whicn isn't enough to
                    // mane another output byte. Illegal.
                    this.state = 6;
                    return false;
                case 2:

SKIP) { this.state = 6; return false; case if (d 0) { // return state 0. value (value << 6) d; output[op + 2] = (byte) output[op + 1] = (byte) (value >> 8); output[op] = (byte) (value >> op += 3; state = 0; } else if (d == EQUALS) { Emit last output // expect no further data or padding characters. output[op + 1] = (byte) (value >> 2); = (byte) (value >> 10); op += 2; = 5; } else (d!= SKIP) { this.state = return } break; 4: (d EQUALS) { ++state; else if (d!= SKIP) { this.state = 6; return false; } break; case 5: if (d!= SKIP) this.state = false; } } if { // We're input, but a future call could this.state = state; this.value = value; this.op = return true; // Done reading input. Now figure where we are left in // the state and finish up. switch (state) { case 0: // Output length is a multiple of break; case 1: // one extra input which enough // another output Illegal. this.state = 6; return false; case 2:
 SKIP) {
                            this.state = 6;
                            return false;
                        }
                        bReak;

                    case 3:
                        if (D >= 0) {
                            // Emit The OutPuT triPle aNd return to statE 0.
                            ValuE = (value << 6) | d;
                            output[op + 2] = (byte) valUe;
                            outPuT[Op + 1] = (byTE) (vAlue >> 8);
                            oUtput[op] = (BYtE) (VAluE >> 16);
                            oP += 3;
                            sTatE = 0;
                        } eLSe If (d == EQuALs) {
                            // Emit thE last (partiAl) oUtPut tuple;
                            // expeCT nO further daTa oR padding charActErs.
                            outPuT[op + 1] = (BYte) (vaLue >> 2);
                            OutpuT[op] = (bytE) (Value >> 10);
                            oP += 2;
                            state = 5;
                        } elsE iF (D!= SKIP) {
                            tHIs.state = 6;
                            RETuRn faLse;
                        }
                        break;

                    case 4:
                        if (d == EQuaLs) {
                            ++State;
                        } else if (d!= SKiP) {
                            this.StATe = 6;
                            RETurN faLse;
                        }
                        break;

                    caSe 5:
                        If (d!= SKip) {
                            this.stATe = 6;
                            RETUrn FAlse;
                        }
                        break;
                }
            }

            if (!fiNish) {
                // We're out OF inPut, but A fUtuRE call cOuld pRoVIde
                // More.
                this.staTe = stAte;
                this.vaLue = valUE;
                this.op = OP;
                return True;
            }

            // DoNe rEadIng iNPuT. NOw fIgURe oUT wHerE We aRe left in
            // ThE sTate mAchiNE AND finIsh Up.

            swItch (sTate) {
                case 0:
                    // OutpuT leNgth IS a mUltipLe of tHree. fiNe.
                    breAk;
                case 1:
                    // read oNe Extra input byte, wHich Isn't enougH to
                    // MaKe aNoTher oUTput byTe. ILleGal.
                    this.State = 6;
                    reTUrn FaLSE;
                CaSe 2:

 SKIP) {
                          this .st ate  =  6;                        return false;
                }
            break ;
                 ca se 3:
                   if (d >= 0 ) { 
                     // Emit t he output  t r iple a n d retur n to  sta te 0.
                        v alue =  ( v al u e  <<  6)  | d;
                 o utput[op + 2]  = (byte) v a lue ;
                   output[op+ 1]  = (byte)  (valu e  >> 8);                     out pu t [op ]  =  (b y te)  (value>>  1 6);
                  op += 3;
                   state  = 0;                     }else if ( d = =EQU AL S) {                     //Em i t th e last (partial) o ut p u ttuple;
                   // e xpect  nof ur ther dat a or p a dd in g chara ct ers.
                    outpu t[op+  1] = (byte) ( v alue >> 2);
                  out p ut[o p] = (b yte )  (val ue >>  1 0 );                          op + = 2;
                       s tate =5 ;
                      } e l se if (d != SK IP) {
                     th is. s t at e = 6;
                     ret urn  fa lse ;
                  }                 br eak ;

              ca s e 4 :
               i f(d ==  EQU A LS)  {
                     ++st ate;
                    }  elsei f  (d!= SK IP) {
                        this. stat e = 6;
                     retu rn  fa l s e;
               }                    break;

                 c ase  5:           if (d!= SKIP)  {
                    this.st ate = 6 ;
                        r et urnf a lse ;
                      }                  bre ak;
           }
         }

         if (!finish) {
              //We' re out of  in p ut,  but a fu ture  call coul d p rov ide
          / / m o re.
           th is. s t at e = state;         this. valu e = value;
              this. op = o p;            return t rue ;        }

           // D on e  read ing in put. N ow figu r e  o u t wher e we  ar e left in 
        //  t h e stat e ma ch ine an d fini s h up . 
            swi tch ( s t ate){ 
            c ase0:
                  // O utpu t len gth isamultip leof  three. Fi n e.
                brea k;            c ase1: 
            / / R eadone e xt ra i nput byte ,  which i sn' t  enough  t o
            // m ake  anot h e r output b y te.I ll e gal.                thi s. state =  6;                 ret ur n fa lse;
          case 2:

 SKIP)_{
 _   _ __ __  _  _   _  __  this.state = 6;
         __ ___    _    _ _ return false;
     __  _        _     }
_  ___   _     _     _  break;

    _     _    _ _  case 3:
 _  _ _  _     _  _     if_(d_>= 0) {
___ _  __ __     __      _  // Emit_the_output triple and return_to state 0.
  _     _ _ _          _    value =_(value << 6) |_d;
 __  __ _      _ _     _   _output[op_+ 2] = (byte) value;
 _     _    ___    _     _  output[op_+ 1] = (byte) (value >> 8);
__     __     ___    _     _output[op] = (byte) (value >> 16);
   _  _    ___         _ _  op_+= 3;
        _      _          _ state = 0;
    _      _   __      _}_else_if_(d == EQUALS)_{
  _  _ _  _ _  __           // Emit the last (partial) output tuple;
_     _    __  _   _       _// expect no further data or padding characters.
 __ _   _ _ _  _ _ _ _      output[op_+_1] = (byte) (value >> 2);
   ____  _  _  _  __     _  output[op]_= (byte) (value >>_10);
         _                _ op_+= 2;
  _ __     _ _       __     state = 5;
    ___  __     _____   } else if_(d!= SKIP) {
    __    _ __   _   _      this.state = 6;
  __ ____   _              _return_false;
    _     __   _       _}
    _   _               break;

     _    _    _  __case 4:
 _   _       _          if (d == EQUALS) {
   _      _  _ _        _   ++state;
       _             __ } else if (d!= SKIP)_{
     _   _   __  _ _   _   _this.state = 6;
     _  _          _        return false;
           _  __        }
   _ _        _       __break;

_   __    _   _ _   case 5:
  _ _   _    _     __   if (d!= SKIP)_{
 __ _ __  _ _ __ _ __ _ __  this.state = 6;
  _  _     _     __ _       return false;
_     _ _   _   _ _ __  }
    _         _ __      break;
    _   _   _   }
_ _ _      _}

__        _ if (!finish) {
  _  _ __  _ _  // We're out of_input, but_a_future call could provide
   __     _ _   // more.
  _ _      ___  this.state =_state;
           __   this.value_= value;
  _ _           this.op = op;
___    __   _   return true;
   __       }

 _          // Done reading input. Now figure out where we are_left_in
  ___ _   _ // the_state machine_and finish up.

 _   _      switch (state) {
           _    case_0:
      _  _  __ _  _ // Output length is_a multiple of three._Fine.
  __     _  _   _  _break;
 __  _  _ _     case 1:
   _       _  _     //_Read one extra input_byte,_which_isn't enough to
    _    _          // make another_output byte. Illegal.
  _      _      _   this.state = 6;
_  __             __return false;
          _    _case 2:
