anchor.diff:  /// different versions of some instructions. For example, we need integer
   /// addition for 8, 16, 32 and 64 bit words.
   abstract class InstructionTemplate {
  -  /// The short name of this opcode, e.g. `push` for a [PushInstruction].
  -  String get name;
  -
     const InstructionTemplate();
   
     /// Execute this instruction on `vm`.
     void execute(VM vm, num immediateArgument);
  +
  +  /// Return a human-readable name for this instruction type.
  +  String format(int immediateArgument);
   }
   
   /// Pushes the immediate argument on the stack.
  
positive.code:       address += chunk.size;
      }
    }
  }
  
  /// Load the value `vm.framePointer` - _immediate value_ to the stack.
  class LoadRelativeAddressInstruction extends InstructionTemplate {
    final NumberType addressSize;
  
    String get name => 'loadr';
  
    const LoadRelativeAddressInstruction(this.addressSize);
  
    void execute(VM vm, int offset) {
      vm.pushStack(addressSize, vm.framePointer - offset);
    }
  }
  
  /// Halts the program execution by throwing [HaltSignal]. Reads the exit code
  /// from the stack as `uint32`.
  class HaltInstruction extends InstructionTemplate {
    String get name => 'halt';
  
    const HaltInstruction();
  
    void execute(VM vm, _) =>
        throw new HaltSignal(vm.popStack(NumberType.uint32));
  }
  
  /// Sets the program counter to the immediate value.
  class JumpInstruction extends InstructionTemplate {
    String get name => 'jump';
  
    const JumpInstruction();
  
    void execute(VM vm, int address) {
      vm.programCounter = address;
    }
  }
  
  /// Pops the top byte from the stack; if it equals zero, jump to the immediate
  /// address.
  class JumpZeroInstruction extends InstructionTemplate {
    String get name => 'jumpz';
  
    const JumpZeroInstruction();
  
    void execute(VM vm, int address) {
      if (vm.popStack(NumberType.uint8) == 0) vm.programCounter = address;
    }
  }
  
  /// Calls the function referenced by the top stack value by setting the program
  
negative.code: 
  /// Logical negation of the top stack element.
  class NegateInstruction extends InstructionTemplate {
    const NegateInstruction();
  
    void execute(VM vm, _) => vm.pushStack(
        NumberType.uint8, vm.popStack(NumberType.uint8) == 0 ? 1 : 0);
  
    String format(int _) => 'not';
  }
  
  /// Thrown when the execution of a program reaches the end of the `main`
  