@aztec/simulator 0.0.0-test.0

package/src/public/avm/opcodes/arithmetic.ts

@@ -0,0 +1,95 @@
+import type { AvmContext } from '../avm_context.js';
+import {
+  type Field,
+  type MemoryValue,
+  TaggedMemory,
+  type TaggedMemoryInterface,
+  TypeTag,
+} from '../avm_memory_types.js';
+import { ArithmeticError } from '../errors.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+
+export abstract class ThreeOperandArithmeticInstruction extends ThreeOperandInstruction {
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.aOffset, this.bOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+    this.checkTags(memory, aOffset, bOffset);
+
+    const a = memory.get(aOffset);
+    const b = memory.get(bOffset);
+
+    const dest = this.compute(a, b);
+    memory.set(dstOffset, dest);
+  }
+
+  protected abstract compute(a: MemoryValue, b: MemoryValue): MemoryValue;
+  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    memory.checkTagsAreSame(aOffset, bOffset);
+  }
+}
+
+export class Add extends ThreeOperandArithmeticInstruction {
+  static readonly type: string = 'ADD';
+  static readonly opcode = Opcode.ADD_8; // FIXME: needed for gas.
+
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    return a.add(b);
+  }
+}
+
+export class Sub extends ThreeOperandArithmeticInstruction {
+  static readonly type: string = 'SUB';
+  static readonly opcode = Opcode.SUB_8; // FIXME: needed for gas.
+
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    return a.sub(b);
+  }
+}
+
+export class Mul extends ThreeOperandArithmeticInstruction {
+  static type: string = 'MUL';
+  static readonly opcode = Opcode.MUL_8; // FIXME: needed for gas.
+
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    return a.mul(b);
+  }
+}
+
+export class Div extends ThreeOperandArithmeticInstruction {
+  static type: string = 'DIV';
+  static readonly opcode = Opcode.DIV_8; // FIXME: needed for gas.
+
+  protected compute(a: MemoryValue, b: MemoryValue): MemoryValue {
+    if (b.toBigInt() === 0n) {
+      throw new ArithmeticError('Division by zero');
+    }
+
+    return a.div(b);
+  }
+
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    memory.checkTagsAreSame(aOffset, bOffset);
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset)); // Follows that bOffset tag is also of integral type
+  }
+}
+
+export class FieldDiv extends ThreeOperandArithmeticInstruction {
+  static type: string = 'FDIV';
+  static readonly opcode = Opcode.FDIV_8; // FIXME: needed for gas.
+
+  protected compute(a: Field, b: Field): Field {
+    // return (a as Field).fdiv(b as Field);
+    return a.fdiv(b);
+  }
+
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    memory.checkTagsAreSame(aOffset, bOffset);
+    memory.checkTag(TypeTag.FIELD, aOffset); // Follows that bOffset has also tag of type Field
+  }
+}

package/src/public/avm/opcodes/bitwise.ts

@@ -0,0 +1,109 @@
+import type { AvmContext } from '../avm_context.js';
+import { type IntegralValue, TaggedMemory, type TaggedMemoryInterface, TypeTag } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+
+abstract class ThreeOperandBitwiseInstruction extends ThreeOperandInstruction {
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.aOffset, this.bOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+    this.checkTags(memory, aOffset, bOffset);
+
+    const a = memory.getAs<IntegralValue>(aOffset);
+    const b = memory.getAs<IntegralValue>(bOffset);
+
+    const res = this.compute(a, b);
+    memory.set(dstOffset, res);
+  }
+
+  protected abstract compute(a: IntegralValue, b: IntegralValue): IntegralValue;
+  protected checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+    memory.checkTagsAreSame(aOffset, bOffset);
+  }
+}
+
+export class And extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'AND';
+  static readonly opcode = Opcode.AND_8; // FIXME: needed for gas.
+
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.and(b);
+  }
+}
+
+export class Or extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'OR';
+  static readonly opcode = Opcode.OR_8; // FIXME: needed for gas.
+
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.or(b);
+  }
+}
+
+export class Xor extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'XOR';
+  static readonly opcode = Opcode.XOR_8; // FIXME: needed for gas.
+
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.xor(b);
+  }
+}
+
+export class Shl extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'SHL';
+  static readonly opcode = Opcode.SHL_8; // FIXME: needed for gas.
+
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.shl(b);
+  }
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+    memory.checkTag(TypeTag.UINT8, bOffset);
+  }
+}
+
+export class Shr extends ThreeOperandBitwiseInstruction {
+  static readonly type: string = 'SHR';
+  static readonly opcode = Opcode.SHR_8; // FIXME: needed for gas.
+
+  protected override compute(a: IntegralValue, b: IntegralValue): IntegralValue {
+    return a.shr(b);
+  }
+  protected override checkTags(memory: TaggedMemoryInterface, aOffset: number, bOffset: number) {
+    TaggedMemory.checkIsIntegralTag(memory.getTag(aOffset));
+    memory.checkTag(TypeTag.UINT8, bOffset);
+  }
+}
+
+export class Not extends Instruction {
+  static readonly type: string = 'NOT';
+  static readonly opcode = Opcode.NOT_8;
+
+  static readonly wireFormat8 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT8, OperandType.UINT8];
+  static readonly wireFormat16 = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT16, OperandType.UINT16];
+
+  constructor(private indirect: number, private srcOffset: number, private dstOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.srcOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
+    TaggedMemory.checkIsIntegralTag(memory.getTag(srcOffset));
+    const value = memory.getAs<IntegralValue>(srcOffset);
+
+    const res = value.not();
+    memory.set(dstOffset, res);
+  }
+}

package/src/public/avm/opcodes/comparators.ts

@@ -0,0 +1,52 @@
+import type { AvmContext } from '../avm_context.js';
+import { type MemoryValue, Uint1 } from '../avm_memory_types.js';
+import { Opcode } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { ThreeOperandInstruction } from './instruction_impl.js';
+
+abstract class ComparatorInstruction extends ThreeOperandInstruction {
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.aOffset, this.bOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [aOffset, bOffset, dstOffset] = addressing.resolve(operands, memory);
+    memory.checkTagsAreSame(aOffset, bOffset);
+
+    const a = memory.get(aOffset);
+    const b = memory.get(bOffset);
+
+    const dest = new Uint1(this.compare(a, b) ? 1 : 0);
+    memory.set(dstOffset, dest);
+  }
+
+  protected abstract compare(a: MemoryValue, b: MemoryValue): boolean;
+}
+
+export class Eq extends ComparatorInstruction {
+  static readonly type: string = 'EQ';
+  static readonly opcode = Opcode.EQ_8; // FIXME: needed for gas.
+
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.equals(b);
+  }
+}
+
+export class Lt extends ComparatorInstruction {
+  static readonly type: string = 'LT';
+  static readonly opcode = Opcode.LT_8; // FIXME: needed for gas.
+
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.lt(b);
+  }
+}
+
+export class Lte extends ComparatorInstruction {
+  static readonly type: string = 'LTE';
+  static readonly opcode = Opcode.LTE_8; // FIXME: needed for gas.
+
+  protected compare(a: MemoryValue, b: MemoryValue): boolean {
+    return a.lt(b) || a.equals(b);
+  }
+}

package/src/public/avm/opcodes/contract.ts

@@ -0,0 +1,72 @@
+import type { AvmContext } from '../avm_context.js';
+import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export enum ContractInstanceMember {
+  DEPLOYER,
+  CLASS_ID,
+  INIT_HASH,
+}
+
+export class GetContractInstance extends Instruction {
+  static readonly type: string = 'GETCONTRACTINSTANCE';
+  static readonly opcode: Opcode = Opcode.GETCONTRACTINSTANCE;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // opcode
+    OperandType.UINT8, // indirect bits
+    OperandType.UINT16, // addressOffset
+    OperandType.UINT16, // dstOffset
+    OperandType.UINT16, // existsOfsset
+    OperandType.UINT8, // member enum (immediate)
+  ];
+
+  constructor(
+    private indirect: number,
+    private addressOffset: number,
+    private dstOffset: number,
+    private existsOffset: number,
+    private memberEnum: number,
+  ) {
+    super();
+  }
+
+  async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    if (!(this.memberEnum in ContractInstanceMember)) {
+      throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
+    }
+
+    const operands = [this.addressOffset, this.dstOffset, this.existsOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [addressOffset, dstOffset, existsOffset] = addressing.resolve(operands, memory);
+    memory.checkTag(TypeTag.FIELD, addressOffset);
+
+    const address = memory.get(addressOffset).toAztecAddress();
+    const instance = await context.persistableState.getContractInstance(address);
+    const exists = instance !== undefined;
+
+    let memberValue = new Field(0);
+    if (exists) {
+      switch (this.memberEnum as ContractInstanceMember) {
+        case ContractInstanceMember.DEPLOYER:
+          memberValue = new Field(instance.deployer.toField());
+          break;
+        case ContractInstanceMember.CLASS_ID:
+          memberValue = new Field(instance.currentContractClassId.toField());
+          break;
+        case ContractInstanceMember.INIT_HASH:
+          memberValue = new Field(instance.initializationHash);
+          break;
+      }
+    }
+
+    memory.set(existsOffset, new Uint1(exists ? 1 : 0));
+    memory.set(dstOffset, memberValue);
+  }
+}

package/src/public/avm/opcodes/control_flow.ts

@@ -0,0 +1,114 @@
+import type { AvmContext } from '../avm_context.js';
+import type { IntegralValue } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class Jump extends Instruction {
+  static type: string = 'JUMP';
+  static readonly opcode: Opcode = Opcode.JUMP_32;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
+
+  constructor(private jumpOffset: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
+    context.machineState.pc = this.jumpOffset;
+  }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
+}
+
+export class JumpI extends Instruction {
+  static type: string = 'JUMPI';
+  static readonly opcode: Opcode = Opcode.JUMPI_32;
+
+  // Instruction wire format with opcode.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT16,
+    OperandType.UINT32,
+  ];
+
+  constructor(private indirect: number, private condOffset: number, private loc: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [this.condOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [condOffset] = addressing.resolve(operands, memory);
+    const condition = memory.getAs<IntegralValue>(condOffset);
+
+    if (condition.toBigInt() == 0n) {
+      context.machineState.pc = context.machineState.nextPc;
+    } else {
+      context.machineState.pc = this.loc;
+    }
+  }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
+}
+
+export class InternalCall extends Instruction {
+  static readonly type: string = 'INTERNALCALL';
+  static readonly opcode: Opcode = Opcode.INTERNALCALL;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8, OperandType.UINT32];
+
+  constructor(private loc: number) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
+    context.machineState.internalCallStack.push({
+      callPc: context.machineState.pc,
+      returnPc: context.machineState.nextPc,
+    });
+    context.machineState.pc = this.loc;
+  }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
+}
+
+export class InternalReturn extends Instruction {
+  static readonly type: string = 'INTERNALRETURN';
+  static readonly opcode: Opcode = Opcode.INTERNALRETURN;
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [OperandType.UINT8];
+
+  constructor() {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    context.machineState.consumeGas(this.gasCost());
+
+    const stackEntry = context.machineState.internalCallStack.pop();
+    if (stackEntry === undefined) {
+      throw new InstructionExecutionError('Internal call stack empty!');
+    }
+    context.machineState.pc = stackEntry.returnPc;
+  }
+
+  public override handlesPC(): boolean {
+    return true;
+  }
+}

package/src/public/avm/opcodes/conversion.ts

@@ -0,0 +1,80 @@
+import type { AvmContext } from '../avm_context.js';
+import { TypeTag, Uint1, Uint8 } from '../avm_memory_types.js';
+import { InvalidToRadixInputsError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class ToRadixBE extends Instruction {
+  static type: string = 'TORADIXBE';
+  static readonly opcode: Opcode = Opcode.TORADIXBE;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // Opcode
+    OperandType.UINT16, // Indirect
+    OperandType.UINT16, // src memory address
+    OperandType.UINT16, // radix memory address
+    OperandType.UINT16, // number of limbs address
+    OperandType.UINT16, // output is in "bits" mode memory address (boolean/Uint1 is stored)
+    OperandType.UINT16, // dst memory address
+  ];
+
+  constructor(
+    private indirect: number,
+    private srcOffset: number,
+    private radixOffset: number,
+    private numLimbsOffset: number,
+    private outputBitsOffset: number,
+    private dstOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    const operands = [this.srcOffset, this.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
+
+    // The radix gadget only takes in a Field
+    memory.checkTag(TypeTag.FIELD, srcOffset);
+    memory.checkTag(TypeTag.UINT32, radixOffset);
+    memory.checkTag(TypeTag.UINT32, numLimbsOffset);
+    memory.checkTag(TypeTag.UINT1, outputBitsOffset);
+
+    const numLimbs = memory.get(numLimbsOffset).toNumber();
+    context.machineState.consumeGas(this.gasCost(numLimbs));
+    const outputBits = memory.get(outputBitsOffset).toNumber();
+
+    let value: bigint = memory.get(srcOffset).toBigInt();
+    const radix: bigint = memory.get(radixOffset).toBigInt();
+
+    if (radix < 2 || radix > 256) {
+      throw new InvalidToRadixInputsError(`ToRadixBE instruction's radix should be in range [2,256] (was ${radix}).`);
+    }
+
+    if (numLimbs < 1 && value != BigInt(0n)) {
+      throw new InvalidToRadixInputsError(
+        `ToRadixBE instruction's input value is not zero (was ${value}) but numLimbs zero.`,
+      );
+    }
+
+    if (outputBits != 0 && radix != BigInt(2n)) {
+      throw new InvalidToRadixInputsError(`Radix ${radix} is not equal to 2 and bit mode is activated.`);
+    }
+
+    const radixBN: bigint = BigInt(radix);
+    const limbArray = new Array(numLimbs);
+
+    for (let i = numLimbs - 1; i >= 0; i--) {
+      const limb = value % radixBN;
+      limbArray[i] = limb;
+      value /= radixBN;
+    }
+
+    const outputType = outputBits != 0 ? Uint1 : Uint8;
+    const res = limbArray.map(byte => new outputType(byte));
+    memory.setSlice(dstOffset, res);
+  }
+}

package/src/public/avm/opcodes/ec_add.ts

@@ -0,0 +1,93 @@
+import { Grumpkin } from '@aztec/foundation/crypto';
+import { Point } from '@aztec/foundation/fields';
+
+import type { AvmContext } from '../avm_context.js';
+import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class EcAdd extends Instruction {
+  static type: string = 'ECADD';
+  static readonly opcode = Opcode.ECADD;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8, // reserved
+    OperandType.UINT16, // indirect
+    OperandType.UINT16, // p1X
+    OperandType.UINT16, // p1Y
+    OperandType.UINT16, // p1IsInfinite
+    OperandType.UINT16, // p2X
+    OperandType.UINT16, // p2Y
+    OperandType.UINT16, // p2IsInfinite
+    OperandType.UINT16, // dst
+  ];
+
+  constructor(
+    private indirect: number,
+    private p1XOffset: number,
+    private p1YOffset: number,
+    private p1IsInfiniteOffset: number,
+    private p2XOffset: number,
+    private p2YOffset: number,
+    private p2IsInfiniteOffset: number,
+    private dstOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory;
+    context.machineState.consumeGas(this.gasCost());
+
+    const operands = [
+      this.p1XOffset,
+      this.p1YOffset,
+      this.p1IsInfiniteOffset,
+      this.p2XOffset,
+      this.p2YOffset,
+      this.p2IsInfiniteOffset,
+      this.dstOffset,
+    ];
+    const addressing = Addressing.fromWire(this.indirect, operands.length);
+    const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
+      addressing.resolve(operands, memory);
+
+    memory.checkTags(TypeTag.FIELD, p1XOffset, p1YOffset, p2XOffset, p2YOffset);
+    memory.checkTags(TypeTag.UINT1, p1IsInfiniteOffset, p2IsInfiniteOffset);
+
+    const p1X = memory.get(p1XOffset);
+    const p1Y = memory.get(p1YOffset);
+    const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
+    const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
+    if (!p1.isOnGrumpkin()) {
+      throw new Error(`Point1 is not on the curve`);
+    }
+
+    const p2X = memory.get(p2XOffset);
+    const p2Y = memory.get(p2YOffset);
+    // unused. Point doesn't store this information
+    const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
+    const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
+    if (!p2.isOnGrumpkin()) {
+      throw new Error(`Point1 is not on the curve`);
+    }
+
+    const grumpkin = new Grumpkin();
+    let dest;
+    if (p1IsInfinite) {
+      dest = p2;
+    } else if (p2IsInfinite) {
+      dest = p1;
+    } else {
+      dest = await grumpkin.add(p1, p2);
+    }
+
+    // Important to use setSlice() and not set() in the two following statements as
+    // this checks that the offsets lie within memory range.
+    memory.setSlice(dstOffset, [new Field(dest.x), new Field(dest.y)]);
+    // Check representation of infinity for grumpkin
+    memory.setSlice(dstOffset + 2, [new Uint1(dest.equals(Point.ZERO) ? 1 : 0)]);
+  }
+}