INP // fetch 'base' value from user
STA :base
init: LDA :base
STA :countdown

multiply: LDA 91 // :base = @90, 91 is next
ADD 90
BRP :nxt // did we overflow ?
LDA :zero 
STA 91 // fill last addess with zero
HLT
nxt: STA 91
LDA :countdown // subtract one from countdown
SUB :one
STA :countdown
BRZ :display // reached zero in 'countdown'
BRA :multiply // back

display: LDA 91
OUT
BRA :selfmod

selfmod: LDA 4 // advance LDA & STA instructions
ADD :one
STA 4
LDA 5
ADD :one
STA 5
LDA 8
ADD :one
STA 8
LDA 10
ADD :one
STA 10
LDA 16 // for display
ADD :one
STA 16
BRA :init

stop: HLT

@90 base: 0
one: 1
end: 0
countdown: 0
zero: 0

public class Lmc
{
   public static final int HLT                  = 0;
   public static final int ADD                  = 1;
   public static final int SUB                  = 2;
   public static final int STA                  = 3;
   public static final int LDA                  = 5;
   public static final int BRA                  = 6;
   public static final int BRZ                  = 7;
   public static final int BRP                  = 8;
   public static final int UIO                  = 9;

   private int             program_counter      = 0;
   private int             execute_counter      = 0;
   private int             last_reference       = 0;
   private int             last_program_counter = 0;
   private int[]           memory               = new int[100];
   private int             boxInput             = 0;
   private int             boxOutput            = 0;
   private int             register;
   private boolean         overflowFlag         = false;

   public Lmc()
   {
      this.init();
   }

   public void load(int[] memory)
   {
      if (memory.length != this.memory.length)
      {
         throw new IllegalStateException("expected " + this.memory.length + " memory values");
      }

      for (int i = 0; i < memory.length; i++)
      {
         if (memory[i] < 0 || memory[i] > 999)
            throw new IllegalStateException("illegal memory value @" + i + ": " + memory[i]);
         this.memory[i] = memory[i];
      }

      this.init();
   }

   public void init()
   {
      this.reset();
      this.execute_counter = 0;
   }

   public void reset()
   {
      this.boxInput = 0;
      this.boxOutput = 0;
      this.register = 0;
      this.overflowFlag = false;
      this.program_counter = 0;
      this.last_program_counter = -1;
      this.last_reference = -1;
   }

   public int getInstructionPointer()
   {
      return this.program_counter;
   }

   public int getLastInstructionPointer()
   {
      return this.last_program_counter;
   }

   public int getLastReference()
   {
      return this.last_reference;
   }

   public boolean getOverflowFlag()
   {
      return this.overflowFlag;
   }

   public int readInbox()
   {
      return this.boxInput;
   }

   public int readOutbox()
   {
      return this.boxOutput;
   }

   public int readRegister()
   {
      return this.register;
   }

   public int readMemory(int address)
   {
      return this.memory[address];
   }

   public int execute(EmulatorFeedback feedback) throws EmulatorCrash
   {
      // fetch instruction
      int data = this.memory[this.program_counter];
      
      this.last_program_counter = program_counter;

      // advance program counter
      this.program_counter += 1;
      this.execute_counter += 1;

      // decode instruction
      int instruction = data / 100;
      int arg = data % 100;
      this.last_reference = arg;

      switch (instruction)
      {
         case HLT:
            this.last_reference = -1;
            if (arg != 0)
            {
               feedback.invalidInstruction();
               throw new EmulatorCrash();
            }
            this.reset();
            feedback.halt();
            break;

         case ADD:
            int doAdd = this.memory[checkAddress(arg, feedback)];
            this.register = normalizeRegister(register + doAdd);
            break;

         case SUB:
            int doSub = this.memory[checkAddress(arg, feedback)];
            this.register = normalizeRegister(register - doSub);
            break;

         case LDA:
            this.register = this.memory[checkAddress(arg, feedback)];
            break;

         case STA:
            this.memory[checkAddress(arg, feedback)] = this.register;
            break;

         case BRA:
            this.program_counter = checkAddress(arg, feedback);
            break;

         case BRZ:
            if (this.register == 0)
               this.program_counter = checkAddress(arg, feedback);
            break;

         case BRP:
            if (!this.overflowFlag)
               this.program_counter = checkAddress(arg, feedback);
            break;

         case UIO:
            this.last_reference = -1;
            switch (arg)
            {
               case 1:
                  this.boxInput = feedback.input();
                  this.register = this.normalizeRegister(this.boxInput);
                  break;

               case 2:
                  this.boxOutput = this.register;
                  feedback.output(this.boxOutput);
                  break;

               default:
                  feedback.invalidInstruction();
                  throw new EmulatorCrash();
            }
            break;

         default:
            break;
      }

      return data;
   }

   private int normalizeRegister(int value)
   {
      final int max = 1000;

      this.overflowFlag = (value < 0 || value >= max);

      return ((value % max) + max) % max; // ensure value between 0 and 999
   }

   private static int checkAddress(int addr, EmulatorFeedback feedback) throws EmulatorCrash
   {
      if (addr < 0 || addr >= 100)
      {
         feedback.invalidAddress(addr);
         throw new EmulatorCrash();
      }
      return addr;
   }
}