// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   KDF9.java

import java.applet.Applet;
import java.awt.*;
import java.io.*;

public class KDF9 extends Applet
{

    void buttonStop()
    {
        clearup();
    }

    void buttonStep()
    {
        int i = nextInstruction;
        if(error || !programCompiled)
        {
            if(!programCompiled)
                compile();
            if(programSize > 0)
                clearAll();
            nextInstruction = 0;
        }
        if(i == nextInstruction && nextInstruction < programSize)
        {
            preInstruction();
            nextInstruction = singleInstruction(nextInstruction);
            postInstruction();
            if(!error)
            {
                if(nextInstruction >= 0 && nextInstruction < programSize)
                {
                    ProgramTextArea.select(command[nextInstruction].instructionFrom(), command[nextInstruction].instructionTo());
                    return;
                }
                if(nextInstruction > 0)
                    ProgramTextArea.select(command[nextInstruction - 1].instructionTo(), command[nextInstruction - 1].instructionTo() + 1);
            }
        }
    }

    void sjPush(long l)
    {
        sjStack[++sjStackTop] = l;
    }

    void buttonRun()
    {
        halt = false;
        if(error || !programCompiled)
        {
            if(!programCompiled)
                compile();
            if(programSize > 0)
                clearAll();
            nextInstruction = 0;
        }
        while(nextInstruction < programSize && !halt && !error) 
            buttonStep();
        ReportArea.setText("PROGRAM COMPLETE");
        halt = false;
    }

    boolean aComment(String s)
    {
        boolean flag = true;
        int i;
        if(s != null && (i = s.length()) > 0 && (s.charAt(0) != '(' || s.charAt(i - 1) != ')'))
            flag = false;
        return flag;
    }

    void InvalidSet(CM cm)
    {
        error = true;
        ReportArea.setText("Integer value out of range " + cm.InstructionText);
    }

    void displayMainStore()
    {
        Store store = listStore;
        String s = "MAIN STORE";
        for(; store != null; store = store.next)
            s = s + "\n" + store.address + " " + getStoreName(store.address) + " =" + store.val;

        MainStoreArea.setText(s);
    }

    int findStoreStart(String s)
    {
        boolean flag = false;
        int j = mainStoreStart.length;
        int i;
        for(i = j; i > 0 && !flag;)
            if(mainStoreName[--i].equals(s))
                flag = true;

        if(!flag)
            i = j;
        return mainStoreStart[i];
    }

    void putInStore(int i, long l)
    {
        Store store = null;
        boolean flag = true;
        store = null;
        Store store1 = listStore;
        while(flag) 
            if(store1 == null || store1.address >= i)
            {
                flag = false;
            } else
            {
                store = store1;
                store1 = store.next;
            }
        if(store1 == null || store1.address > i)
        {
            Store store2 = new Store(i, l);
            store2.next = store1;
            if(store == null)
                listStore = store2;
            else
                store.next = store2;
        } else
        {
            store1.val = l;
        }
        storeChanged = true;
    }

    void putInStore(String s, int i, long l)
    {
        putInStore(getStoreAddress(s, i), l);
    }

    long pull()
    {
        return stack[stackTop--];
    }

    void processTrailingQ(CM cm)
    {
        int i = cm.getComponents();
        if(i > 3 && cm.compares(i, "Q") && cm.isInteger(i - 1) && cm.compares(i - 2, "M"))
        {
            int j = cm.getInteger(i - 1);
            if(j > 0)
            {
                M[j] += I[j];
                C[j]--;
            }
            QStoresChanged = true;
        }
    }

    void postInstruction()
    {
        boolean flag = false;
        if(stackChanged)
        {
            displayStack();
            flag = true;
        }
        if(sjStackChanged)
        {
            displaySjStack();
            flag = true;
        }
        if(QStoresChanged)
        {
            displayQStores();
            flag = true;
        }
        if(storeChanged)
        {
            displayMainStore();
            flag = true;
        }
        if(flag)
            outerPanel.validate();
    }

    public static void main(String args[])
    {
        BufferedReader bufferedreader = null;
        boolean flag = false;
        boolean flag1 = false;
        fromAnApplet = false;
        F = new Frame("KDF9 SIMULATOR");
        F.addWindowListener(new  Object()     /* anonymous class not found */
    class _anm1 {}

);
        F.setSize(700, 520);
        F.setLocation(50, 50);
        K = new KDF9();
        K.outerPanel = K;
        if(args != null && args.length > 0)
            try
            {
                bufferedreader = new BufferedReader(new FileReader(args[0]));
                flag = true;
            }
            catch(FileNotFoundException _ex)
            {
                System.out.println("File " + args[0] + " not found");
                flag = false;
            }
        if(!flag)
        {
            System.out.println("run with   java filename");
            System.out.println("where filename is the name of the file ");
            System.out.println("with the source code of the KDF9 program");
        } else
        {
            K.fileName = args[0];
            boolean flag2 = false;
            int i = 0;
            while(!flag2) 
                try
                {
                    String s = bufferedreader.readLine();
                    if(s == null)
                        flag2 = true;
                    else
                    if(++i == 1)
                        K.programString = s;
                    else
                        K.programString = K.programString + "\n" + s;
                }
                catch(IOException _ex)
                {
                    flag1 = true;
                }
            if(flag1)
                System.out.println("Errors reading file " + args[0]);
        }
        if(flag && !flag1)
        {
            F.add("Center", K.outerPanel);
            F.setVisible(true);
            K.setupInterface(K.outerPanel);
            K.compile();
        }
    }

    void buttonStart()
    {
        halt = false;
        if(!programCompiled)
            compile();
        if(programSize > 0)
            clearAll();
        nextInstruction = 0;
    }

    void buttonSave()
    {
        try
        {
            PrintWriter printwriter = new PrintWriter(new BufferedWriter(new FileWriter(fileName)));
            String s = ProgramTextArea.getText();
            if(s != null || s.length() > 0)
            {
                int i = -1;
                do
                {
                    int j = i + 1;
                    i = s.indexOf('\n', j);
                    int k;
                    if(i < 0)
                        k = s.length();
                    else
                        k = i;
                    printwriter.println(s.substring(j, k));
                } while(i >= 0);
            }
            printwriter.flush();
            printwriter.close();
            ReportArea.setText("FILE SAVED SUCCESSFULLY: " + fileName);
            outerPanel.validate();
            return;
        }
        catch(IOException _ex)
        {
            ReportArea.setText("ERROR WRITING FILE: " + fileName);
        }
        outerPanel.validate();
    }

    long stackCell(int i)
    {
        return stack[(stackTop + 1) - i];
    }

    void clearAll()
    {
        error = false;
        ReportArea.setText("PROGRAM");
        stackTop = -1;
        sjStackTop = -1;
        int i = 0;
        do
        {
            C[i] = 0;
            I[i] = 0;
            M[i] = 0;
        } while(++i <= 15);
        listStore = null;
        displayStack();
        displaySjStack();
        displayQStores();
        displayMainStore();
        outerPanel.validate();
        if(programSize > 0)
            ProgramTextArea.select(command[0].instructionFrom(), command[0].instructionTo());
    }

    boolean noOverflow(int i, CM cm)
    {
        if(stackTop + i > 16)
        {
            error = true;
            ReportArea.setText("Stack overflow on instruction " + cm.InstructionText);
            return false;
        } else
        {
            return true;
        }
    }

    boolean sjNoUnderflow(CM cm)
    {
        if(sjStackTop == -1)
        {
            error = true;
            ReportArea.setText("Jump Stack underflow on instruction " + cm.InstructionText);
            return false;
        } else
        {
            return true;
        }
    }

    String getStoreName(int i)
    {
        int j = mainStoreName.length;
        boolean flag;
        for(flag = false; j > 0 && !flag;)
            if(mainStoreStart[--j] <= i)
                flag = true;

        if(!flag)
            return "??" + i;
        else
            return mainStoreName[j] + (i - mainStoreStart[j]);
    }

    boolean processToQ(CM cm)
    {
        boolean flag = true;
        int i = cm.getInteger(2);
        int j = cm.getInteger(4);
        String s = cm.getText(1);
        if(s.equals("Q"))
            s = "CIM";
        for(int k = 0; k < s.length(); k++)
            switch(s.charAt(k))
            {
            case 67: // 'C'
                C[j] = C[i];
                break;

            case 73: // 'I'
                I[j] = I[i];
                break;

            case 77: // 'M'
                M[j] = M[i];
                // fall through

            default:
                flag = false;
                break;
            }

        stackChanged = true;
        return flag;
    }

    boolean noUnderflow(int i, CM cm)
    {
        if(stackTop + 1 < i)
        {
            error = true;
            ReportArea.setText("Stack underflow on instruction " + cm.InstructionText);
            return false;
        } else
        {
            return true;
        }
    }

    void displaySjStack()
    {
        String s = "SJNS";
        for(int i = sjStackTop; i >= 0; i--)
            s = s + "\n" + sjStack[i];

        SjStackArea.setText(s);
        outerPanel.validate();
    }

    boolean processSet(CM cm)
    {
        boolean flag = false;
        if(noOverflow(1, cm))
        {
            if(cm.com == 3001)
            {
                flag = true;
                long l = cm.getInteger(2);
                if(l <= 32767L && l >= -32768L)
                    push(cm.getInteger(2));
                else
                    InvalidSet(cm);
            } else
            if(cm.com == 3002)
            {
                String s = cm.getText(1);
                s = s.substring(4, s.length());
                int i = getStoreAddress(s, cm.getInteger(2));
                if(i > 0)
                {
                    flag = true;
                    push(i);
                }
            }
            stackChanged = true;
        }
        return flag;
    }

    int findInstructionWithLabel(int i)
    {
        int j = 0;
        for(boolean flag = false; j < programSize && !flag;)
            if(programLabel[j] == i)
                flag = true;
            else
                j++;

        return j;
    }

    boolean processStore(CM cm)
    {
        boolean flag = true;
        if(noUnderflow(1, cm))
        {
            String s = cm.getText(2);
            char c = s.charAt(0);
            char c1 = ' ';
            boolean flag1 = false;
            int j = 0;
            long l = 0L;
            int k = s.length();
            if(k == 2)
                c1 = s.charAt(1);
            if(cm.isInteger(3))
                j = cm.getInteger(3);
            switch(c)
            {
            case 81: // 'Q'
                long l1 = pull();
                if(j > 0)
                {
                    C[j] = (short)(int)(l1 >> 32 & 65535L);
                    I[j] = (short)(int)(l1 >> 16 & 65535L);
                    M[j] = (short)(int)(l1 & 65535L);
                }
                QStoresChanged = true;
                break;

            case 67: // 'C'
                long l2 = pull();
                putInQ('C', j, l2);
                QStoresChanged = true;
                break;

            case 73: // 'I'
                long l3 = pull();
                putInQ('I', j, l3);
                QStoresChanged = true;
                break;

            case 77: // 'M'
                long l4 = pull();
                putInQ('M', j, l4);
                QStoresChanged = true;
                break;

            case 82: // 'R'
                long l5 = pull();
                putInQ(c1, j, l5);
                QStoresChanged = true;
                if(k >= 2)
                    c1 = s.charAt(1);
                if(j > 0)
                    if(c1 == 'C')
                    {
                        I[j] = 1;
                        M[j] = 0;
                    } else
                    if(c1 == 'I')
                    {
                        C[j] = 0;
                        M[j] = 0;
                    } else
                    if(c1 == 'M')
                    {
                        C[j] = 0;
                        I[j] = 1;
                    }
                break;

            case 84: // 'T'
                long l6 = pull();
                if(l6 < 0L)
                    TestRegister = 1;
                else
                    TestRegister = 0;
                // fall through

            default:
                long l7 = pull();
                int i = getStoreAddress(cm, 2);
                if(i == 0)
                    flag = false;
                else
                    putInStore(i, l7);
                processTrailingQ(cm);
                break;
            }
            stackChanged = true;
        }
        return flag;
    }

    boolean processSingleText(CM cm)
    {
        boolean flag = true;
        switch(cm.com)
        {
        case 1021: 
            break;

        case 1056: 
            if(noOverflow(1, cm))
                push(0L);
            break;

        case 1022: 
            if(noOverflow(1, cm) && noUnderflow(1, cm))
                push(stack[stackTop]);
            break;

        case 1023: 
            if(noOverflow(2, cm) && noUnderflow(2, cm))
            {
                push(stack[stackTop - 1]);
                push(stack[stackTop - 1]);
            }
            break;

        case 1001: 
            if(noUnderflow(2, cm))
                push(pull() + pull());
            break;

        case 1005: 
            if(noUnderflow(2, cm))
            {
                long l = pull();
                stack[stackTop] -= l;
            }
            break;

        case 1024: 
            if(noUnderflow(1, cm))
                stackTop--;
            break;

        case 1031: 
            if(noUnderflow(1, cm))
                push(-pull());
            break;

        case 1036: 
            if(noUnderflow(1, cm))
                push(-pull() - 1L);
            break;

        case 1039: 
            if(noUnderflow(2, cm))
            {
                long l1 = stack[stackTop];
                stack[stackTop] = stack[stackTop - 1];
                stack[stackTop - 1] = l1;
            }
            break;

        case 1040: 
            if(noUnderflow(4, cm))
            {
                long l2 = stack[stackTop];
                long l8 = stack[stackTop - 1];
                stack[stackTop] = stack[stackTop - 2];
                stack[stackTop - 1] = stack[stackTop - 3];
                stack[stackTop - 2] = l2;
                stack[stackTop - 3] = l8;
            }
            break;

        case 1038: 
            if(noUnderflow(3, cm))
            {
                long l3 = stack[stackTop];
                stack[stackTop] = stack[stackTop - 1];
                stack[stackTop - 1] = stack[stackTop - 2];
                stack[stackTop - 2] = l3;
            }
            break;

        case 1019: 
            if(noUnderflow(3, cm))
            {
                long l4 = stack[stackTop];
                stack[stackTop] = stack[stackTop - 2];
                stack[stackTop - 2] = stack[stackTop - 1];
                stack[stackTop - 1] = l4;
            }
            break;

        case 1052: 
            if(noUnderflow(2, cm))
                push(pull() * pull());
            push(0L);
            break;

        case 1015: 
            if(noUnderflow(1, cm))
                push(Math.abs(pull()));
            break;

        case 1020: 
            if(!noUnderflow(2, cm))
                break;
            long l5 = pull();
            long l9 = stack[stackTop];
            if(l5 < 0L && l9 >= 0L || l5 >= 0L && l9 < 0L)
                push(-pull());
            break;

        case 1050: 
            overflowRegister = 0;
            break;

        case 1045: 
            if(!noUnderflow(2, cm))
                break;
            long l6 = pull();
            long l10 = pull();
            if(l6 < l10)
            {
                push(1L);
                break;
            }
            if(l6 > l10)
                push(-1L);
            else
                push(0L);
            break;

        case 1013: 
            if(noUnderflow(2, cm))
            {
                long l7 = pull();
                long l11 = pull();
                push(l11 / l7);
                push(l11 % l7);
            }
            break;

        default:
            flag = false;
            break;
        }
        stackChanged = true;
        return flag;
    }

    String remove(String s, char c)
    {
        int i = s.indexOf(c);
        if(i < 0)
            return s;
        if(i == s.length() - 1)
            return s.substring(0, i);
        else
            return s.substring(0, i) + remove(s.substring(i + 1, s.length()), c);
    }

    long sjPull()
    {
        return sjStack[sjStackTop--];
    }

    long sjStackCell(int i)
    {
        return sjStack[(sjStackTop + 1) - i];
    }

    int getStoreAddress(String s, int i)
    {
        int j = mainStoreName.length;
        boolean flag;
        for(flag = false; j > 0 && !flag;)
            if(mainStoreName[--j].equals(s))
                flag = true;

        if(flag)
            return mainStoreStart[j] + i;
        else
            return i;
    }

    int getStoreAddress(CM cm, int i)
    {
        String s = cm.getText(i);
        int j = 0;
        int k = 0;
        if(cm.isInteger(i + 1))
            j = cm.getInteger(i + 1);
        k = getStoreAddress(s, j);
        if(cm.compares(i + 2, "M"))
            k += M[cm.getInteger(i + 3)];
        return k;
    }

    boolean processNCDC(CM cm)
    {
        boolean flag = false;
        int i = cm.getInteger(2);
        if(i > 0)
        {
            if(cm.com == 7001)
            {
                C[i] = (short)(-C[i]);
                flag = true;
            } else
            if(cm.com == 7002)
            {
                C[i]--;
                flag = true;
            }
            QStoresChanged = true;
        }
        return flag;
    }

    public KDF9()
    {
        fileName = "";
        programString = "";
        programSize = 0;
        programCompiled = false;
        TestRegister = 0;
        overflowRegister = 0;
        error = false;
        stack = new long[16];
        stackTop = -1;
        sjStack = new long[16];
        sjStackTop = -1;
        C = new short[16];
        I = new short[16];
        M = new short[16];
        listStore = null;
        nextInstruction = 0;
        stackChanged = false;
        sjStackChanged = false;
        QStoresChanged = false;
        storeChanged = false;
        halt = false;
    }

    long getFromStore(int i)
    {
        Store store = listStore;
        boolean flag = true;
        while(flag) 
            if(store == null || store.address >= i)
                flag = false;
            else
                store = store.next;
        if(store != null && store.address == i)
            return store.val;
        else
            return 0L;
    }

    boolean processVStore(CM cm)
    {
        boolean flag = false;
        return flag;
    }

    void compile()
    {
        programSize = 0;
        programString = ProgramTextArea.getText();
        if(programString != null || programString.length() > 0)
        {
            int i = -1;
            do
            {
                int i1 = i + 1;
                i = programString.indexOf('\n', i1);
                int k1;
                if(i < 0)
                    k1 = programString.length();
                else
                    k1 = i;
                String s = programString.substring(i1, k1);
                int k = -1;
                do
                {
                    int i2 = k + 1;
                    k = s.indexOf(';', i2);
                    if(k >= i2)
                    {
                        String s2 = s.substring(i2, k).trim();
                        if(!aComment(s2) && aLabel(s2) <= 0)
                            programSize++;
                    }
                } while(k >= 0);
            } while(i >= 0);
            command = new CM[programSize];
            programLabel = new int[programSize];
            for(i = 0; i < programSize; i++)
                programLabel[i] = 0;

            int l2 = -1;
            i = -1;
            do
            {
                int j1 = i + 1;
                i = programString.indexOf('\n', j1);
                int l1;
                if(i < 0)
                    l1 = programString.length();
                else
                    l1 = i;
                String s1 = programString.substring(j1, l1);
                int l = -1;
                do
                {
                    int j2 = l + 1;
                    l = s1.indexOf(';', j2);
                    if(l >= j2)
                    {
                        String s3 = s1.substring(j2, l).trim();
                        if(!aComment(s3))
                        {
                            int i3 = aLabel(s3);
                            if(i3 >= 0)
                            {
                                if(l2 + 1 < programSize)
                                    programLabel[l2 + 1] = i3;
                            } else
                            {
                                l2++;
                                s3 = remove(s3, ' ');
                                s3 = remove(s3, '\t');
                                s3 = s3.toUpperCase();
                                int k2 = s3.length();
                                if(s3.charAt(0) == 'X')
                                    s3 = 'x' + s3.substring(1, k2);
                                command[l2] = new CM(s3, programLabel[l2], j1 + j2, j1 + l);
                            }
                        }
                    }
                } while(l >= 0);
            } while(i >= 0);
            for(int j = 0; j < programSize; j++)
                programCompiled = true;

        }
    }

    void displayQStores()
    {
        String s = "C";
        int i = 1;
        do
            s = s + "\n" + C[i];
        while(++i <= 15);
        CArea.setText(s);
        s = "I";
        i = 1;
        do
            s = s + "\n" + I[i];
        while(++i <= 15);
        IArea.setText(s);
        s = "M";
        i = 1;
        do
            s = s + "\n" + M[i];
        while(++i <= 15);
        MArea.setText(s);
    }

    boolean processFetch(CM cm)
    {
        boolean flag = false;
        if(noOverflow(1, cm))
        {
            String s = cm.getText(1);
            char c = s.charAt(0);
            boolean flag1 = false;
            int j = 0;
            if(cm.isInteger(2))
                j = cm.getInteger(2);
            switch(c)
            {
            case 81: // 'Q'
                push(((long)(C[j] << 16) | (long)I[j] & 65535L) << 16 | (long)M[j] & 65535L);
                flag = true;
                break;

            case 67: // 'C'
                push(C[j]);
                flag = true;
                break;

            case 73: // 'I'
                push(I[j]);
                flag = true;
                break;

            case 77: // 'M'
                push(M[j]);
                flag = true;
                break;

            default:
                int i = getStoreAddress(cm, 1);
                if(i > 0)
                {
                    flag = true;
                    push(getFromStore(i));
                    processTrailingQ(cm);
                }
                break;
            }
            stackChanged = true;
        }
        return flag;
    }

    boolean sjNoOverflow(CM cm)
    {
        if(sjStackTop == 16)
        {
            error = true;
            ReportArea.setText("Jump Stack overflow on instruction " + cm.InstructionText);
            return false;
        } else
        {
            return true;
        }
    }

    void push(long l)
    {
        stack[++stackTop] = l;
    }

    void displayStack()
    {
        String s = "STACK";
        for(int i = stackTop; i >= 0; i--)
            s = s + "\n" + stack[i];

        StackArea.setText(s);
        outerPanel.validate();
    }

    void putInQ(char c, int i, long l)
    {
        if(i > 0)
        {
            switch(c)
            {
            case 67: // 'C'
                C[i] = (short)(int)l;
                break;

            case 73: // 'I'
                I[i] = (short)(int)l;
                break;

            case 77: // 'M'
                M[i] = (short)(int)l;
                break;
            }
            QStoresChanged = true;
        }
    }

    int aLabel(String s)
    {
        int k = 0;
        boolean flag = false;
        int j;
        if(s != null && (j = s.length()) > 0)
        {
            flag = true;
            for(int i = 0; i < j && flag; i++)
            {
                char c = s.charAt(i);
                if(c >= '0' && c <= '9')
                    k = (k * 10 + c) - 48;
                else
                    flag = false;
            }

        }
        if(flag)
            return k;
        else
            return -1;
    }

    void NoInstruction(CM cm)
    {
        error = true;
        ReportArea.setText("Instruction not implemented or found " + cm.InstructionText);
    }

    void preInstruction()
    {
        stackChanged = false;
        sjStackChanged = false;
        QStoresChanged = false;
        storeChanged = false;
    }

    int processJumpInstruction(CM cm, int i)
    {
        boolean flag = true;
        int j = i + 1;
        switch(cm.com)
        {
        case 4002: 
            j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4026: 
            break;

        case 4009: 
            if(stackTop < 0)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4010: 
            if(stackTop >= 0)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4011: 
            if(sjStackTop < 0)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4012: 
            if(sjStackTop >= 0)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4013: 
            if(C[cm.getInteger(4)] == 0)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4014: 
            if(C[cm.getInteger(4)] != 0)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4016: 
            if(noUnderflow(1, cm) && pull() >= 0L)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4017: 
            if(noUnderflow(1, cm) && pull() > 0L)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4018: 
            if(noUnderflow(1, cm) && pull() == 0L)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4019: 
            if(noUnderflow(1, cm) && pull() != 0L)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4021: 
            if(noUnderflow(1, cm) && pull() <= 0L)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4020: 
            if(noUnderflow(1, cm) && pull() < 0L)
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4022: 
            if(noUnderflow(2, cm) && pull() == stack[stackTop])
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4023: 
            if(noUnderflow(2, cm) && pull() != stack[stackTop])
                j = findInstructionWithLabel(cm.getInteger(2));
            break;

        case 4004: 
            if(sjNoOverflow(cm))
            {
                sjPush(i);
                j = findInstructionWithLabel(cm.getInteger(2));
            }
            break;

        case 4024: 
            if(sjNoUnderflow(cm))
                j = (int)sjPull();
            break;

        case 4025: 
            if(sjNoUnderflow(cm))
                j = (int)sjPull() + cm.getInteger(2);
            break;

        default:
            flag = false;
            break;
        }
        stackChanged = true;
        if(!flag)
            return -1;
        else
            return j;
    }

    void setupInterface(Panel panel)
    {
        panel.setLayout(new BorderLayout(5, 5));
        Panel panel1 = new Panel(new BorderLayout(5, 5));
        ProgramTextArea = new TextArea("", 12, 80, 0);
        ProgramTextArea.addTextListener(new  Object()     /* anonymous class not found */
    class _anm2 {}

);
        ProgramTextArea.setText(programString);
        ProgramTextArea.setEditable(true);
        ReportArea = new TextArea("PROGRAM", 1, 80, 3);
        panel1.add("North", ReportArea);
        panel1.add("Center", ProgramTextArea);
        Panel panel2 = new Panel(new GridLayout(5, 1));
        BtoStart = new Button("Top");
        Bstep = new Button("Step");
        Brun = new Button("Run");
        Bstop = new Button("Stop");
        Bsave = new Button("Save");
        panel2.add(BtoStart);
        panel2.add(Bstep);
        panel2.add(Brun);
        if(!fromAnApplet)
        {
            panel2.add(Bsave);
            panel2.add(Bstop);
        }
        _cls3 _lcls3 = new  Object()     /* anonymous class not found */
    class _anm3 {}

;
        BtoStart.addActionListener(_lcls3);
        Bstep.addActionListener(_lcls3);
        Brun.addActionListener(_lcls3);
        if(!fromAnApplet)
        {
            Bstop.addActionListener(_lcls3);
            Bsave.addActionListener(_lcls3);
        }
        panel1.add("East", panel2);
        panel.add("North", panel1);
        Panel panel3 = new Panel(new FlowLayout());
        StackArea = new TextArea("", 17, 16, 3);
        panel3.add(StackArea);
        displayStack();
        SjStackArea = new TextArea("", 17, 6, 3);
        panel3.add(SjStackArea);
        displaySjStack();
        TextArea textarea = new TextArea("", 17, 3, 3);
        textarea.setText("\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16");
        panel3.add(textarea);
        CArea = new TextArea("", 17, 6, 3);
        IArea = new TextArea("", 17, 6, 3);
        MArea = new TextArea("", 17, 6, 3);
        panel3.add(CArea);
        panel3.add(IArea);
        panel3.add(MArea);
        displayQStores();
        MainStoreArea = new TextArea("", 17, 26, 1);
        panel3.add(MainStoreArea);
        displayMainStore();
        panel.add("Center", panel3);
        panel.validate();
    }

    public static void clearup()
    {
        K = null;
        F = null;
        System.exit(0);
    }

    void InvalidExit(CM cm)
    {
        error = true;
        ReportArea.setText("Invalid Exit statement - Use 'Exit x'where x is a multiple of 3");
    }

    public void init()
    {
        outerPanel = this;
        setupInterface(outerPanel);
    }

    boolean processIEqual(CM cm)
    {
        int i = cm.getInteger(2);
        if(i > 0)
        {
            M[i] += cm.getInteger(4);
            QStoresChanged = true;
        }
        return true;
    }

    int singleInstruction(int i)
    {
        CM cm = command[i];
        cm.getComponents();
        int j = i + 1;
        int k = cm.com;
        boolean flag = false;
        int l = k / 100;
        switch(l)
        {
        case 10: // '\n'
            flag = processSingleText(cm);
            break;

        case 20: // '\024'
            flag = processStore(cm);
            break;

        case 30: // '\036'
            flag = processSet(cm);
            break;

        case 40: // '('
            j = processJumpInstruction(cm, i);
            if(j < 0)
                flag = false;
            else
                flag = true;
            break;

        case 50: // '2'
            flag = processVStore(cm);
            break;

        case 60: // '<'
            flag = processIEqual(cm);
            break;

        case 70: // 'F'
            flag = processNCDC(cm);
            break;

        case 80: // 'P'
            flag = processToQ(cm);
            break;

        case 90: // 'Z'
            flag = processFetch(cm);
            break;
        }
        if(!flag)
            NoInstruction(cm);
        return j;
    }

    static boolean fromAnApplet = true;
    static final int EMPTY = -1;
    static final long mask16 = 65535L;
    static Frame F;
    static KDF9 K;
    String fileName;
    String programString;
    int programSize;
    String programLine[];
    boolean programCompiled;
    CM command[];
    int programLabel[];
    Panel outerPanel;
    TextArea ProgramTextArea;
    int TestRegister;
    int overflowRegister;
    boolean error;
    TextArea ReportArea;
    long stack[];
    int stackTop;
    TextArea StackArea;
    long sjStack[];
    int sjStackTop;
    TextArea SjStackArea;
    short C[];
    short I[];
    short M[];
    TextArea CArea;
    TextArea IArea;
    TextArea MArea;
    String mainStoreName[] = {
        "V", "W", "YA", "YB", "YC", "YD", "Y"
    };
    int mainStoreStart[] = {
        1000, 2000, 3000, 4000, 5000, 6000, 7000
    };
    Store listStore;
    TextArea MainStoreArea;
    int nextInstruction;
    Button BtoStart;
    Button Bstep;
    Button Brun;
    Button Bstop;
    Button Bsave;
    boolean stackChanged;
    boolean sjStackChanged;
    boolean QStoresChanged;
    boolean storeChanged;
    boolean halt;

}