anchor.diff:    final NumberType from;
     final NumberType to;
   
  -  String get name => 'cast<$from↦$to>';
  -
     const TypeConversionInstruction(this.from, this.to);
   
     void execute(VM vm, _) => vm.pushStack(to, vm.popStack(from));
  +
  +  String format(int _) => 'cast<$from↦$to>';
   }
   
   /// Superclass for all side effect-free arithmetic, bitwise and logical
  
positive.code: /// Points the frame pointer to the top of the stack (and therefore on the
  /// return address).
  class CallInstruction extends InstructionTemplate {
    final NumberType addressSize;
  
    String get name => 'call';
  
    const CallInstruction(this.addressSize);
  
    void execute(VM vm, int offset) {
      vm.programCounter = vm.popStack(addressSize);
  
negative.code:     vm.pushStack(addressSize, vm.programCounter);
      vm.framePointer = vm.stackPointer;
    }
  
    String format(int value) => 'call ${value * instructionSize.size}';
  }
  
  /// Completes the runtime context of a function invocation by setting the
  /// extreme pointer.
  class EnterFunctionInstruction extends InstructionTemplate {
    const EnterFunctionInstruction();
  
    void execute(VM vm, int offset) {
      vm.extremePointer = vm.framePointer - offset;
    }
  
    String format(int value) => 'enter $value';
  }
  
  /// Returns from a function call. Restores the organizational registers from the
  /// backed up values on the stack.
  class ReturnInstruction extends InstructionTemplate {
    const ReturnInstruction();
  
    void execute(VM vm, _) {
      var localOffset = (int n) => vm.framePointer + n * addressSize.size;
  