/*
 * This file was created automatically from SUIF
 *   on Mon Mar 16 14:36:38 1998.
 *
 * Created by:
 * s2c 5.138 (plus local changes) compiled Wed Aug 13 18:35:11 MET DST 1997 by muller on drogo
 *     Based on SUIF distribution 1.1.2
 *     Linked with:
 *   libsuif 5.228 compiled Thu Nov 7 14:46:16 MET 1996 by marlet on drogo
 *   libuseful 1.243 compiled Thu Nov 7 14:51:28 MET 1996 by marlet on drogo
 */


struct inst { int opcode;
              int val; };

extern int mem[];
extern int stack[];
extern int top;
extern int prg_size;
extern struct inst prg[];

extern void interpret(struct inst *);
extern int printf();
extern int exit();

extern void interpret(struct inst *prg)
  {
    int pc;
    int sp;

    pc = 0;
    sp = 0;
    if (pc < prg_size)
      {
        do
          {
            printf("OPCODE= %d mem[0]=%d, mem[1]=%d\n", prg[pc].opcode, *mem, mem[1]);
            if (prg[pc].opcode == 0)
              {
                sp = sp + 1;
                stack[sp] = prg[pc].val;
                pc = pc + 1;
              }
            else
              {
                if (prg[pc].opcode == 1)
                  {
                    sp = sp - 1;
                    pc = pc + 1;
                  }
                else
                  {
                    if (prg[pc].opcode == 2)
                      {
                        stack[sp - 1] = stack[sp] + stack[sp - 1];
                        sp = sp - 1;
                        pc = pc + 1;
                      }
                    else
                      {
                        if (prg[pc].opcode == 3)
                          {
                            stack[sp - 1] = stack[sp - 1] - stack[sp];
                            sp = sp - 1;
                            pc = pc + 1;
                          }
                        else
                          {
                            if (prg[pc].opcode == 4)
                              {
                                stack[sp - 1] = stack[sp] * stack[sp - 1];
                                sp = sp - 1;
                                pc = pc + 1;
                              }
                            else
                              {
                                if (prg[pc].opcode == 5)
                                  {
                                    stack[sp] = mem[stack[sp]];
                                    pc = pc + 1;
                                  }
                                else
                                  {
                                    if (prg[pc].opcode == 6)
                                      {
                                        mem[stack[sp]] = stack[sp - 1];
                                        sp = sp - 2;
                                        pc = pc + 1;
                                      }
                                    else
                                      {
                                        if (prg[pc].opcode == 7)
                                          {
                                            pc = stack[sp];
                                            sp = sp - 1;
                                          }
                                        else
                                          {
                                            if (prg[pc].opcode == 8)
                                              {
                                                if (stack[sp - 1] != 0)
                                                  {
                                                    pc = stack[sp];
                                                  }
                                                else
                                                  {
                                                    pc = pc + 1;
                                                  }
                                                sp = sp - 2;
                                              }
                                            else
                                              {
                                                if (prg[pc].opcode == 9)
                                                  {
                                                    stack[sp - 1] = stack[sp] == stack[sp - 1];
                                                    sp = sp - 1;
                                                    pc = pc + 1;
                                                  }
                                                else
                                                  {
                                                    printf("\n Unrecognized instruction -> %d at %d\n", prg[pc].opcode, pc);
                                                    exit();
                                                  }
                                              }
                                          }
                                      }
                                  }
                              }
                          }
                      }
                  }
              }
          } while (pc < prg_size);
      }
    return;
  }