int locVarPos = ((int) code[pc + 1]) & 0xff;        float f = sf.popFloat();        sf.setLocalFloat(locVarPos, f);        ++pc;    }    private void executeFSTORE_N(int locVarPos) {        float f = sf.popFloat();        sf.setLocalFloat(locVarPos, f);        ++pc;    }    private void executeFSUB() {        float value2 = sf.popFloat();        float value1 = sf.popFloat();        float result = value1 - value2;        sf.pushFloat(result);        ++pc;    }    private void executeGETSTATIC() {			// This is hard-coded for the Play Ball! simulation.			// This simulation code doesn't simulate the constant			// pool, because it was only used once or twice in all			// the bytecode sequences. In Play Ball!'s bytecode			// sequence, getstatic refers to constant pool entry			// six, which refers to a class variable named ball that			// is of type Ball.			sf.pushObject(constantPool[6].getStaticField());			pc += 3;	}    private void executeGOTO() {        branch();    }    private void executeI2B() {        int value = sf.popInt();        int result = (byte) value;        sf.pushInt(result);        ++pc;    }    private void executeI2C() {        int value = sf.popInt();        int result = (char) value;        sf.pushInt(result);        ++pc;    }    private void executeI2D() {        int value = sf.popInt();        double result = (double) value;        sf.pushDouble(result);        ++pc;    }    private void executeI2F() {        int value = sf.popInt();        float result = (float) value;        sf.pushFloat(result);        ++pc;    }    private void executeI2L() {        int value = sf.popInt();        long result = (long) value;        sf.pushLong(result);        ++pc;    }    private void executeI2S() {        int value = sf.popInt();        int result = (short) value;        sf.pushInt(result);        ++pc;    }    private void executeIADD() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 + value2;        sf.pushInt(result);        ++pc;    }    private void executeIAND() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 & value2;        sf.pushInt(result);        ++pc;    }    private void executeIASTORE() {        // Pop int value.        int value = sf.popInt();        // Pop index.        int index = sf.popInt();        // Pop reference to an array of integers. Must cast the generic object        // reference to a reference to an array of integers, then use that        // to assign arrayRef[index] = value.        int[] theArray = (int[]) sf.popObject();        theArray[index] = value;        ++pc;    }    private void executeICONST_N(int i) {        sf.pushInt(i);        ++pc;    }    private void executeIDIV() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 / value2;        sf.pushInt(result);        ++pc;    }    private void executeIF_ICMPCOND(int condition) {        int value2 = sf.popInt();        int value1 = sf.popInt();        boolean branch = compare(condition, value1, value2);        if (branch) {            branch();        }        else {            pc += 3;        }    }    private void executeIFCOND(int condition) {        int value = sf.popInt();        boolean branch = compare(condition, value, 0);        if (branch) {            branch();        }        else {            pc += 3;        }    }    private void executeIINC() {        int index = code[pc + 1];        index &= 0xff; // index is an unsigned byte        int constant = code[pc + 2]; // constant is a signed byte        int locVar = sf.getLocalInt(index);        locVar += constant;        sf.setLocalInt(index, locVar);        pc += 3;    }    private void executeILOAD() {        int locVarPos = ((int) code[pc + 1]) & 0xff;        int val = sf.getLocalInt(locVarPos);        sf.pushInt(val);        ++pc;    }    private void executeILOAD_N(int locVarPos) {        int val = sf.getLocalInt(locVarPos);        sf.pushInt(val);        ++pc;    }    private void executeIMUL() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 * value2;        sf.pushInt(result);        ++pc;    }    private void executeINEG() {        int value = sf.popInt();        int result = -value;        sf.pushInt(result);        ++pc;    }    private void executeINVOKESTATIC() {        // Hardcoded to invoke Math.random() for Slice of Pi        double value = sf.popDouble();        double result = Math.sqrt(value);        sf.pushDouble(result);        pc += 3;    }    private void executeIOR() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 | value2;        sf.pushInt(result);        ++pc;    }    private void executeIREM() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 % value2;        sf.pushInt(result);        ++pc;    }    private void executeISHL() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 << (value2 & 0x1f);        sf.pushInt(result);        ++pc;    }    private void executeISHR() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 >> (value2 & 0x1f);        sf.pushInt(result);        ++pc;    }    private void executeISTORE() {        int locVarPos = ((int) code[pc + 1]) & 0xff;        int val = sf.popInt();        sf.setLocalInt(locVarPos, val);        pc += 2;    }    private void executeISTORE_N(int locVarPos) {        int val = sf.popInt();        sf.setLocalInt(locVarPos, val);        ++pc;    }    private void executeISUB() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 - value2;        sf.pushInt(result);        ++pc;    }    private void executeIUSHR() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 >>> (value2 & 0x1f);        sf.pushInt(result);        ++pc;    }    private void executeIXOR() {        int value2 = sf.popInt();        int value1 = sf.popInt();        int result = value1 ^ value2;        sf.pushInt(result);        ++pc;    }    private void executeJSR() {        int offset = getShortOperand(pc + 1);        sf.pushReturnAddress(new ReturnAddress(pc + 3));        pc += offset;    }    private void executeL2D() {        long value = sf.popLong();        double result = (double) value;        sf.pushDouble(result);        ++pc;    }    private void executeL2F() {        long value = sf.popLong();        float result = (float) value;        sf.pushFloat(result);        ++pc;    }    private void executeL2I() {        long value = sf.popLong();        int result = (int) value;        sf.pushInt(result);        ++pc;    }    private void executeLADD() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 + value2;        sf.pushLong(result);        ++pc;    }    private void executeLAND() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 & value2;        sf.pushLong(result);        ++pc;    }    private void executeLCONST_N(long theLong) {        sf.pushLong(theLong);        ++pc;    }    private void executeLDC2_W() {        short cpIndex = getShortOperand(pc + 1);        // Hardcoded for Slices of Pi        if (cpIndex == 6) {            sf.pushDouble(0.5);        }        else if (cpIndex == 8) {            sf.pushDouble(2.0);        }        else if (cpIndex == 10) {            sf.pushDouble(4.0);        }        pc += 3;    }    private void executeLDIV() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 / value2;        sf.pushLong(result);        ++pc;    }    private void executeLLOAD() {        int locVarPos = ((int) code[pc + 1]) & 0xff;        long theLong = sf.getLocalLong(locVarPos);        sf.pushLong(theLong);        pc += 2;    }    private void executeLLOAD_N(int locVarPos) {        long theLong = sf.getLocalLong(locVarPos);        sf.pushLong(theLong);        ++pc;    }    private void executeLMUL() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 * value2;        sf.pushLong(result);        ++pc;    }    private void executeLNEG() {        long value = sf.popLong();        long result = -value;        sf.pushLong(result);        ++pc;    }    private void executeLOR() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 | value2;        sf.pushLong(result);        ++pc;    }    private void executeLREM() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 % value2;        sf.pushLong(result);        ++pc;    }    private void executeLSHL() {        int value2 = sf.popInt();        long value1 = sf.popLong();        long result = value1 << (value2 & 0x3f);        sf.pushLong(result);        ++pc;    }    private void executeLSHR() {        int value2 = sf.popInt();        long value1 = sf.popLong();        long result = value1 >> (value2 & 0x3f);        sf.pushLong(result);        ++pc;    }    private void executeLSTORE() {        int locVarPos = ((int) code[pc + 1]) & 0xff;        long theLong = sf.popLong();        sf.setLocalLong(locVarPos, theLong);        pc += 2;    }    private void executeLSTORE_N(int locVarPos) {        long theLong = sf.popLong();        sf.setLocalLong(locVarPos, theLong);        ++pc;    }    private void executeLSUB() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 - value2;        sf.pushLong(result);        ++pc;    }    private void executeLUSHR() {        int value2 = sf.popInt();        long value1 = sf.popLong();        long result = value1 >>> (value2 & 0x3f);        sf.pushLong(result);        ++pc;    }    private void executeLXOR() {        long value2 = sf.popLong();        long value1 = sf.popLong();        long result = value1 ^ value2;        sf.pushLong(result);        ++pc;    }    private void executeMULTIANEWARRAY() {        int index = getShortOperand(pc + 1);        int dim = code[pc + 3];        if (dim < 1) {            throw new JVMSimError();        }        // Fill an array with the sizes of the various arrays. The sizes go into the        // array in the order in which they appear in the declaration, left to right.        // This was the same order in which they were pushed onto the stack. Therefore,        // the first element is assigned the value most buried (furthest down) in the        // stack.        int[] size = new int[dim];        for (int i = dim - 1; i >= 0; --i) {            size[i] = sf.popInt();        }        // This time around, I'll just assume it's an array of ints. In the future, I'll        // need to check the constant pool and pass down the type.        Object result = createMultiDimArray(size);        sf.pushObject(result);        pc += 4;    }	private void executePOP() {		sf.pop();		++pc;	}    private void executeRET() {        int index = ((int) code[pc + 1]) & 0xff;        ReturnAddress returnAddress = (ReturnAddress) sf.getLocalObject(index);        pc = returnAddress.getReturnAddress();    }    private void executeSIPUSH() {        short theShort = getShortOperand(pc + 1);        sf.pushInt(theShort);        pc += 3;    }    private void executeTABLESWITCH() {        // Skip zero to three places so the addresses are 32-bit aligned assuming        // that the first instruction in the method is at address zero.        int padding = (pc + 1) % 4;        int pcPlusPadding = pc + padding;        // Get the default branch offset        int offset = getIntOperand(pcPlusPadding + 1);        // Get the low value        int low = getIntOperand(pcPlusPadding + 5);        // Get the high value        int high = getIntOperand(pcPlusPadding + 9);        // Pop the index (the value of the switch expression) off        // of the stack        int index = sf.popInt();        // If the index is within the low-high range, grab an offset        // from the table. Else, use the default offset.        if ((index >= low) || (index <= high)) {            int result = index - low;            result *= 4;            result += pcPlusPadding + 12;            // Get the branch offset            offset = getIntOperand(result + 1);        }        pc += offset;    }}