/*
 * This file was created automatically from SUIF
 *   on Tue Mar 17 08:46:23 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 *, int, int);
extern int printf();
extern int exit();

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