anchor.diff:  ///
   /// Points the frame pointer to the top of the stack (and therefore on the
   /// return address).
  -class CallInstruction extends InstructionTemplate {
  +class CallInstruction extends InstructionImplementation {
  +  String get name => 'call';
  +
  +  int get immediateArgumentSize => addressSize.sizeInBytes;
  +
     const CallInstruction();
   
     void execute(VM vm, int offset) {
  
positive.code:       ..extremePointer = vm.readMemoryValue(localOffset(3), addressSize)
        ..framePointer = vm.readMemoryValue(localOffset(2), addressSize);
    }
  
    String format(int _) => 'return';
  }
  
  /// Converts the top stack element between the specified types. Instead of
  /// reinterpreting the memory, the value is retained. For example, executing a
  /// type conversion `double32 ↦ int32` on the value `1.0` yields `1` (which has
  /// a different bit pattern).
  class TypeConversionInstruction extends InstructionTemplate {
    final NumberType from;
    final NumberType 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
  /// operators with two operands. Subclasses need only implement the `calculate`
  /// method.
  abstract class ArithmeticOperationInstruction extends InstructionTemplate {
    final NumberType numberType;
  
    String get name;
  
    const ArithmeticOperationInstruction(this.numberType);
  
    /// Pop two `numberType` elements from the stack, pass them to `calculate`
    /// and push the result back onto the stack.
    void execute(VM vm, _) {
      var arg1 = vm.popStack(numberType);
      var arg2 = vm.popStack(numberType);
      vm.pushStack(numberType, calculate(arg1, arg2));
    }
  
    /// Extension point for subclasses; implements the specific operation.
    num calculate(num op1, num op2);
  
    String format(int _) => name;
  }
  
  /// Adds the two top stack elements.
  class AddInstruction extends ArithmeticOperationInstruction {
    String get name => 'add<${numberType}>';
  
    const AddInstruction(numberType) : super(numberType);
  
    num calculate(num a, num b) => a + b;
  }
  
  /// Subtracts the two top stack elements.
  class SubtractInstruction extends ArithmeticOperationInstruction {
    String get name => 'sub<${numberType}>';
  
    const SubtractInstruction(numberType) : super(numberType);
  
    num calculate(num a, num b) => a - b;
  }
  
  /// Multiplies the two top stack elements.
  class MultiplyInstruction extends ArithmeticOperationInstruction {
    String get name => 'mul<${numberType}>';
  
    const MultiplyInstruction(numberType) : super(numberType);
  
    num calculate(num a, num b) => a * b;
  }
  
  /// Divides the two top stack elements.
  class DivideInstruction extends ArithmeticOperationInstruction {
    String get name => 'div<${numberType}>';
  
    const DivideInstruction(numberType) : super(numberType);
  
    num calculate(num a, num b) =>
        numberType.memoryInterpretation == double ? a / b : a ~/ b;
  }
  
  /// Calculates the modulo of the two top stack elements.
  class ModuloInstruction extends ArithmeticOperationInstruction {
    String get name => 'mod<${numberType}>';
  
    const ModuloInstruction(numberType) : super(numberType);
  
    int calculate(int a, int b) => a % b;
  }
  
  /// Arithmetic inversion of the top stack element.
  class InverseInstruction extends InstructionTemplate {
    final NumberType numberType;
  
    const InverseInstruction(this.numberType);
  
    void execute(VM vm, _) => vm.pushStack(numberType, -vm.popStack(numberType));
  
    String format(int _) => 'neg<${numberType}>';
  }
  
  /// Bitwise inverse of the top stack element.
  class BitwiseNotInstruction extends InstructionTemplate {
    final NumberType numberType;
  
    const BitwiseNotInstruction(this.numberType);
  
    void execute(VM vm, _) =>
        vm.pushStack(numberType, ~(vm.popStack(numberType) as int));
  
    String format(int _) => 'inv<${numberType}>';
  }
  
  /// Bitwise _and_ of the two top stack elements.
  class BitwiseAndInstruction extends ArithmeticOperationInstruction {
    String get name => 'and<${numberType}>';
  
    const BitwiseAndInstruction(numberType) : super(numberType);
  
    int calculate(int a, int b) => a & b;
  }
  
  /// Bitwise _or_ of the two top stack elements.
  class BitwiseOrInstruction extends ArithmeticOperationInstruction {
    String get name => 'or<${numberType}>';
  
    const BitwiseOrInstruction(numberType) : super(numberType);
  
    int calculate(int a, int b) => a | b;
  }
  
  /// Bitwise _xor_ of the two top stack elements.
  class BitwiseExclusiveOrInstruction extends ArithmeticOperationInstruction {
    String get name => 'xor<${numberType}>';
  
    const BitwiseExclusiveOrInstruction(numberType) : super(numberType);
  
    int calculate(int a, int b) => a ^ b;
  }
  
  /// Compares the two top stack elements using `==`.
  class EqualsInstruction extends ArithmeticOperationInstruction {
    String get name => 'eq<${numberType.sizeInBits}>';
  
    const EqualsInstruction(numberType) : super(numberType);
  
    int calculate(num a, num b) => a == b ? 1 : 0;
  }
  
  /// Compares the two top stack elements using `>`.
  class GreaterThanInstruction extends ArithmeticOperationInstruction {
    String get name => 'gt<${numberType}>';
  
    const GreaterThanInstruction(numberType) : super(numberType);
  
    int calculate(num a, num b) => a > b ? 1 : 0;
  }
  
  /// Compares the two top stack elements using `≥`.
  class GreaterEqualsInstruction extends ArithmeticOperationInstruction {
    String get name => 'ge<${numberType}>';
  
    const GreaterEqualsInstruction(numberType) : super(numberType);
  
    int calculate(num a, num b) => a >= b ? 1 : 0;
  }
  
  /// Compares the two top stack elements using `<`.
  class LessThanInstruction extends ArithmeticOperationInstruction {
    String get name => 'lt<${numberType}>';
  
    const LessThanInstruction(numberType) : super(numberType);
  
    int calculate(num a, num b) => a < b ? 1 : 0;
  }
  
  /// Compares the two top stack elements using `≤`.
  class LessEqualsInstruction extends ArithmeticOperationInstruction {
    String get name => 'le<${numberType}>';
  
    const LessEqualsInstruction(numberType) : super(numberType);
  
    int calculate(num a, num b) => a <= b ? 1 : 0;
  }
  
  /// 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`
  
negative.code: 
    /// References the instruction type, or [opcode]
    /// (https://en.wikipedia.org/wiki/Opcode).
    InstructionImplementation implementation;
  
    /// If `implementation` does not expect an argument, return `null`. Else
    /// resolve `immediateValue` to an integer value.
  