break;  case 0x5C: stack[sp] = (stack[sp] != 0) ? 0 : 1;
  private boolean executeInstruction(ByteBuffer inst)  {    if (TRACE_EXECUTION)      dumpInstruction(inst);    int i, count, e1, e2, e3, e4, x, y;    int bcode = inst.get() & 0xff;    switch (bcode)    {    case 0x00: // SVTCA[0], Set freedom and proj. Vectors To Coord. Axis [y]      setFreedomVector((short) 0, ONE_214);      setProjectionVector((short) 0, ONE_214);      break;    case 0x01: // SVTCA[1], Set freedom and proj. Vectors To Coord. Axis [x]      setFreedomVector(ONE_214, (short) 0);      setProjectionVector(ONE_214, (short) 0);      break;    case 0x02: // SPVTCA[0], Set Projection Vector To Coordinate Axis [y]      setProjectionVector((short) 0, ONE_214);      break;    case 0x03: // SPVTCA[1], Set Projection Vector To Coordinate Axis [x]      setProjectionVector(ONE_214, (short) 0);      break;    case 0x0c: // GPV, Get Projection Vector      stack[++sp] = projX;      stack[++sp] = projY;      break;    case 0x0d: // GPV, Get Freedom Vector      stack[++sp] = freeX;      stack[++sp] = freeY;      break;    case 0x0F: // ISECT, move point p to the InterSECTION of two lines      sp -= 4;      handleISECT(stack[sp], stack[sp+1], stack[sp+2],                  stack[sp+3], stack[sp+4]);      break;    case 0x10: // SRP0, Set Reference Point 0      rp0 = stack[sp--];      break;    case 0x11: // SRP1, Set Reference Point 1      rp1 = stack[sp--];      break;    case 0x12: // SRP2, Set Reference Point 2      rp2 = stack[sp--];      break;    case 0x13: // SZP0, Set Zone Pointer 0      zp0 = getZone(stack[sp--]);      break;    case 0x14: // SZP1, Set Zone Pointer 1      zp1 = getZone(stack[sp--]);      break;    case 0x15: // SZP2, Set Zone Pointer 2      zp2 = getZone(stack[sp--]);      break;    case 0x16: // SZPS, Set Zone PointerS      zp0 = zp1 = zp2 = getZone(stack[sp--]);      break;          case 0x17: // SLOOP, Set LOOP variable      loop = stack[sp--];      break;    case 0x18: // RTG, Round To Grid      setRoundingMode(Fixed.ONE, 0x48);      break;    case 0x19: // RTHG, Round To Half Grid      setRoundingMode(Fixed.ONE, 0x68);      break;    case 0x1a: // SMD, Set Minimum Distance      minimumDistance = stack[sp--];      break;    case 0x1B: // ELSE, ELSE clause      skipAfter(inst,                /* look for: EIF, -- */ 0x59, -1,                /* illegal: --, -- */   -1, -1,                /* handle nested if clauses */ true);      break;          case 0x1C: // JMPR, JuMP Relative      inst.position(inst.position() - 1 + stack[sp--]);      break;    case 0x1D: // SCVTCI, Set Control Value Table Cut-In      cvtCutIn = stack[sp--];      break;    case 0x1F: // SSW, Set Single Width      singleWidthValue = stack[sp--];      break;    case 0x20: // DUP, DUPlicate top stack element      e1 = stack[sp];      stack[++sp] = e1;      break;    case 0x21: // POP, POP top stack element      sp--;      break;    case 0x22: // CLEAR, CLEAR the stack      sp = -1;      break;    case 0x23: // SWAP, SWAP the top two elements on the stack      e1 = stack[sp--];      e2 = stack[sp];      stack[sp] = e1;      stack[++sp] = e2;      break;    case 0x24: // DEPTH, DEPTH of the stack      stack[++sp] = sp + 1;      break;    case 0x25: // CINDEX, Copy the INDEXed element to the top of the stack      stack[sp] = stack[sp - stack[sp]];      break;    case 0x26: // MINDEX, Move the INDEXed element to the top of the stack      i = stack[sp];      e1 = stack[sp - i];      System.arraycopy(/* src */ stack,  /* srcPos */ sp - i + 1,                       /* dest */ stack, /* destPos*/ sp - i,                       /* length */ i - 1);      --sp;      stack[sp] = e1;      break;    case 0x2a: // LOOPCALL, LOOP and CALL function      i = stack[sp--];      count = stack[sp--];      e1 = inst.position();      e2 = sp;      for (int j = 0; j < count; j++)        execute(fdefBuffer[i], fdefEntryPoint[i]);      inst.position(e1);      break;    case 0x2B: // CALL, CALL function      i = stack[sp--];      e1 = inst.position();      e2 = sp;      execute(fdefBuffer[i], fdefEntryPoint[i]);      inst.position(e1);      break;          case 0x2C: // FDEF, Function DEFinition      i = stack[sp--];      fdefBuffer[i] = inst;      fdefEntryPoint[i] = inst.position();      skipAfter(inst,                /* look for: ENDF */ 0x2d,                /* look for: --- */ -1,                /* illegal: IDEF */ 0x89,                /* illegal: FDEF */ 0x2c,                /* do not handle nested if clauses */ false);      break;    case 0x2D: // ENDF, END Function definition      /* Pop the current stack frame. */      return false;    case 0x2e: // MDAP[0], Move Direct Absolute Point      handleMDAP(stack[sp--], /* round */ false);      break;    case 0x2f: // MDAP[1], Move Direct Absolute Point      handleMDAP(stack[sp--], /* round */ true);      break;    case 0x39: // IP, Interpolate Point by the last relative stretch      handleIP();      break;    case 0x3d: // RTDG, Round To Double Grid      setRoundingMode(Fixed.ONE, 0x08);      roundThreshold = roundThreshold / 64; // period/128      break;    case 0x3e: // MIAP[0], Move Indirect Absolute Point      e1 = stack[sp--];      handleMIAP(e1, stack[sp--], /* round */ false);      break;    case 0x3f: // MIAP[1], Move Indirect Absolute Point      e1 = stack[sp--];      handleMIAP(e1, stack[sp--], /* round */ true);      break;    case 0x40: // NPUSHB      count = inst.get() & 0xff;      for (i = 0; i < count; i++)        stack[++sp] = inst.get() & 0xff;      break;    case 0x41: // NPUSHW      count = inst.get() & 0xff;      for (i = 0; i < count; i++)        stack[++sp] = inst.getShort();      break;    case 0x42: // WS, Write Store      e1 = stack[sp--]; i = stack[sp--];      storage[i] = e1;      break;    case 0x43: // RS, Read Store      stack[sp] = storage[stack[sp]];      break;    case 0x44: // WCVTP, Write Control Value Table in Pixel units      e1 = stack[sp--];      i = stack[sp--];      if (i < cvt.length)        cvt[i] = e1;      break;    case 0x45: // RCVT, Read Control Value Table entry      if (stack[sp] < cvt.length)        stack[sp] = cvt[stack[sp]];      else        stack[sp] = 0;      break;    case 0x46: // GC[0], Get Coordinate projected onto the projection vector      stack[sp] = getProjection(zp2, stack[sp]);      break;    case 0x47: // GC[1], Get Coordinate projected onto the projection vector      stack[sp] = getOriginalProjection(zp2, stack[sp]);      break;    case 0x4B: // MPPEM, Measure Pixels Per EM      stack[++sp] = getPixelsPerEM();      break;    case 0x4c: // MPS, Measure Point Size      /* FreeType2 returns pixels per em here, because they think that       * the point size would be irrelevant in a given font program.       * This is extremely surprising, because the appearance of good       * fonts _should_ change with point size. For example, a good       * font should be wider at small point sizes, and the holes       * inside glyphs ("Punzen" in German, I do not know the correct       * English expression) should be larger. Note that this change       * of appearance is dependent on point size, _not_ the       * resolution of the display device.       */      stack[++sp] = pointSize;      break;    case 0x4f: // DEBUG, DEBUG call      sp--;      break;    case 0x50: // LT, Less Than      e1 = stack[sp--];      stack[sp] = (stack[sp] < e1) ? 1 : 0;      break;    case 0x51: // LTEQ, Greater Than or EQual      e1 = stack[sp--];      stack[sp] = (stack[sp] <= e1) ? 1 : 0;      break;    case 0x52: // GT, Greater Than      e1 = stack[sp--];      stack[sp] = (stack[sp] > e1) ? 1 : 0;      break;    case 0x53: // GTEQ, Greater Than or EQual      e1 = stack[sp--];      stack[sp] = (stack[sp] >= e1) ? 1 : 0;      break;    case 0x54: // EQ, EQual      e1 = stack[sp--];      stack[sp] = (stack[sp] == e1) ? 1 : 0;      break;    case 0x55: // NEQ, Not EQual      e1 = stack[sp--];      stack[sp] = (stack[sp] != e1) ? 1 : 0;      break;    case 0x58: // IF, IF test      if (stack[sp--] == 0)        skipAfter(inst,                  /* look for: ELSE */ 0x1B,                  /* look for: EIF */  0x59,                  /* illegal: -- */    -1,                  /* illegal: -- */    -1,                  /* handle nested if clauses */ true);      break;    case 0x59: // EIF, End IF      // Do nothing.      break;    case 0x5A: // AND      e1 = stack[sp--];      stack[sp] = ((e1 != 0) && (stack[sp] != 0)) ? 1 : 0;      break;    case 0x5B: // OR      e1 = stack[sp--];      stack[sp] = ((e1 != 0) || (stack[sp] != 0)) ? 1 : 0;      break;    case 0x5e: // SDB, Set Delta Base in the graphics state      deltaBase = stack[sp--];      break;    case 0x5f: // SDS, Set Delta Shift in the graphics state      deltaShift = stack[sp--];      break;    case 0x60: // ADD      e1 = stack[sp--];      stack[sp] += e1;      break;    case 0x61: // SUB, SUBtract      e1 = stack[sp--];      stack[sp] -= e1;      break;    case 0x62: // DIV, DIVide      e1 = stack[sp--];      stack[sp] = Fixed.div(e1, stack[sp]);      break;    case 0x63:  // MUL, MULtiply      e1 = stack[sp--];      stack[sp] = Fixed.mul(e1, stack[sp]);      break;    case 0x64: // ABS, ABSolute value      stack[sp] = Math.abs(stack[sp]);      break;    case 0x65: // NEG, NEGate      stack[sp] = -stack[sp];      break;    case 0x66: // FLOOR      stack[sp] = Fixed.floor(stack[sp]);      break;    case 0x67: // CEILING      stack[sp] = Fixed.ceil(stack[sp]);      break;    case 0x68: // ROUND[0] -- round grey distance      stack[sp] = round(stack[sp], /* no engine compensation */ 0);      break;    case 0x69: // ROUND[1] -- round black distance      stack[sp] = round(stack[sp], -engineCompensation);      break;    case 0x6a: // ROUND[2] -- round white distance      stack[sp] = round(stack[sp], engineCompensation);      break;    case 0x6b: // ROUND[3] -- round distance (not yet defined)      stack[sp] = round(stack[sp], /* no engine compensation */ 0);      break;    case 0x6c: // NROUND[0] -- compensate grey distance      stack[sp] = nround(stack[sp], 0);      break;    case 0x6d: // NROUND[1] -- compensate black distance      stack[sp] = nround(stack[sp], -engineCompensation);      break;    case 0x6e: // NROUND[2] -- compensate white distance      stack[sp] = nround(stack[sp], engineCompensation);      break;    case 0x6f: // NROUND[3] -- compensate distance (not yet defined)      stack[sp] = nround(stack[sp], 0);      break;    case 0x70: // WCVTF, Write Control Value Table in Funits      e1 = stack[sp--];      cvt[stack[sp--]] = e1 * getPixelsPerEM();      break;    case 0x73: // DELTAC1, DELTA exception C1      count = stack[sp--];      sp -= 2 * count;      deltaC(stack, sp + 1, count, 0);      break;    case 0x74: // DELTAC2, DELTA exception C2      count = stack[sp--];      sp -= 2 * count;      deltaC(stack, sp + 1, count, 16);      break;    case 0x75: // DELTAC3, DELTA exception C3      count = stack[sp--];      sp -= 2 * count;      deltaC(stack, sp + 1, count, 32);      break;        case 0x76: // SROUND, Super ROUND      setRoundingMode(Fixed.ONE, stack[sp--]);      break;    case 0x77: // S45ROUND, Super ROUND 45 degrees      setRoundingMode(/* sqrt(2)/2 */ 0x2d, stack[sp--]);      break;    case 0x78: // JROT, Jump Relative On True      e1 = stack[sp--];      i = inst.position() - 1 + stack[sp--];      if (e1 != 0)        inst.position(i);      break;    case 0x79: // JROF, Jump Relative On False      e1 = stack[sp--];      i = inst.position() - 1 + stack[sp--];      if (e1 == 0)        inst.position(i);      break;    case 0x7a: // ROFF, Round OFF      roundPeriod = 0;      break;    case 0x7c: // RUTG, Round Up To Grid      setRoundingMode(Fixed.ONE, 0x40);            break;    case 0x7d: // RDTG, Round Down To Grid      setRoundingMode(Fixed.ONE, 0x40);      roundThreshold = 0;      break;    case 0x7e: // SANGW, Set ANGle Weight (no-op according to TrueType spec)    case 0x7f: // AA, Adjust Angle (no-op according to TrueType spec)      sp--;      break;    case 0x85: // SCANCTRL, SCAN conversion ConTRoL      e1 = stack[sp--];      int ppemThreshold = e1 & 255;      scanControl = false;      boolean ppemCondition = (ppemThreshold == 255)        || ((ppemThreshold != 0) && (getPixelsPerEM() > ppemThreshold));      if (((e1 & (1<<8)) != 0) && ppemCondition)        scanControl = true;      if (((e1 & (1<<9)) != 0) && isRotated())        scanControl = true;      if (((e1 & (1<<10)) != 0) && isStretched())        scanControl = true;      if (((e1 & (1<<11)) != 0) && !ppemCondition)        scanControl = false;      if (((e1 & (1<<12)) != 0) && !isRotated())        scanControl = false;      if (((e1 & (1<<13)) != 0) && !isStretched())        scanControl = false;      break;    case 0x88: // GETINFO, GET INFOrmation      e1 = 0;      if ((stack[sp] & 1) != 0) // ask for rasterizer version        e1 |= 35; // "Microsoft Rasterizer version 1.7" (grayscale-capable)      if (((stack[sp] & 2) != 0) && isRotated())        e1 |= 1 << 8; // bit 8: glyph has been rotated      if (((stack[sp] & 4) != 0) && isStretched())        e1 |= 1 << 9; // bit 9: glyph has been stretched      if (((stack[sp] & 32) != 0) && antialiased)        e1 |= 1 << 12; // bit 12: antialiasing is active      stack[sp] = e1;      break;    case 0x8a: // ROLL, ROLL the top three stack elements      e1 = stack[sp - 2];      stack[sp - 2] = stack[sp - 1];      stack[sp - 1] = stack[sp];      stack[sp] = e1;      break;    case 0x8b: // MAX, MAXimum of top two stack elements      e1 = stack[sp--];      stack[sp] = Math.max(e1, stack[sp]);      break;    case 0x8c: // MIN, MINimum of top two stack elements      e1 = stack[sp--];      stack[sp] = Math.min(e1, stack[sp]);      break;    case 0x8d: // SCANTYPE      scanType = stack[sp--];      break;    case 0x8e: // INSTCTRL, INSTRuction execution ConTRoL      e1 = stack[sp--]; // selector      e2 = stack[sp--]; // value      switch (e1)      {      case 1:        executeGlyphInstructions = (e2 == 0);        break;      case 2:        ignoreCVTProgram = (e2 != 0);        break;      }      break;          case 0xb0: // PUSHB[0]    case 0xb1: // PUSHB[1]    case 0xb2: // PUSHB[2]    case 0xb3: // PUSHB[3]    case 0xb4: // PUSHB[4]    case 0xb5: // PUSHB[5]    case 0xb6: // PUSHB[6]    case 0xb7: // PUSHB[7]      count = bcode - 0xb0 + 1;      for (i = 0; i < count; i++)        stack[++sp] = inst.get() & 0xff;      break;    case 0xb8: // PUSHW[0]    case 0xb9: // PUSHW[1]    case 0xba: // PUSHW[2]    case 0xbb: // PUSHW[3]    case 0xbc: // PUSHW[4]    case 0xbd: // PUSHW[5]    case 0xbe: // PUSHW[6]    case 0xbf: // PUSHW[7]      count = bcode - 0xb8 + 1;      for (i = 0; i < count; i++)        stack[++sp] = inst.getShort();      break;      // MIRPxxxx, Move Indirect Relative Point    case 0xe0: case 0xe1: case 0xe2: case 0xe3:    case 0xe4: case 0xe5: case 0xe6: case 0xe7:    case 0xe8: case 0xe9: case 0xea: case 0xeb:    case 0xec: case 0xed: case 0xee: case 0xef:    case 0xf0: case 0xf1: case 0xf2: case 0xf3:    case 0xf4: case 0xf5: case 0xf6: case 0xf7:    case 0xf8: case 0xf9: case 0xfa: case 0xfb:    case 0xfc: case 0xfd: case 0xfe: case 0xff:      e1 = stack[sp--];      handleMIRP(bcode, /* point */ e1, /* cvtIndex */ stack[sp--]);      break;    default:      throw new IllegalStateException();    }    return true;  }