// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
//
// This file has been automatically generated. Please do not edit it manually.
// To regenerate the file, run the following script:
//
// > dart benchmarks/FfiCall/generate_benchmarks.dart

// Using part of, so that the library uri is identical to the main file.
// That way the FfiNativeResolver works for the main uri.
part of 'FfiCall.dart';

typedef Function1int = int Function(int);
typedef Function2int = int Function(int, int);
typedef Function4int = int Function(int, int, int, int);
typedef Function10int =
    int Function(int, int, int, int, int, int, int, int, int, int);
typedef Function20int =
    int Function(
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
      int,
    );
typedef Function1double = double Function(double);
typedef Function2double = double Function(double, double);
typedef Function4double = double Function(double, double, double, double);
typedef Function10double =
    double Function(
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
    );
typedef Function20double =
    double Function(
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
      double,
    );
typedef Function1PointerUint8 = Pointer<Uint8> Function(Pointer<Uint8>);
typedef Function2PointerUint8 =
    Pointer<Uint8> Function(Pointer<Uint8>, Pointer<Uint8>);
typedef Function4PointerUint8 =
    Pointer<Uint8> Function(
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
    );
typedef Function10PointerUint8 =
    Pointer<Uint8> Function(
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
    );
typedef Function20PointerUint8 =
    Pointer<Uint8> Function(
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
    );
typedef Function1Object = Object Function(Object);
typedef Function2Object = Object Function(Object, Object);
typedef Function4Object = Object Function(Object, Object, Object, Object);
typedef Function10Object =
    Object Function(
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
    );
typedef Function20Object =
    Object Function(
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
      Object,
    );
typedef NativeFunction1Int8 = Int8 Function(Int8);
typedef NativeFunction2Int8 = Int8 Function(Int8, Int8);
typedef NativeFunction4Int8 = Int8 Function(Int8, Int8, Int8, Int8);
typedef NativeFunction10Int8 =
    Int8 Function(Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8, Int8);
typedef NativeFunction20Int8 =
    Int8 Function(
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
      Int8,
    );
typedef NativeFunction1Int16 = Int16 Function(Int16);
typedef NativeFunction2Int16 = Int16 Function(Int16, Int16);
typedef NativeFunction4Int16 = Int16 Function(Int16, Int16, Int16, Int16);
typedef NativeFunction10Int16 =
    Int16 Function(
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
    );
typedef NativeFunction20Int16 =
    Int16 Function(
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
      Int16,
    );
typedef NativeFunction1Int32 = Int32 Function(Int32);
typedef NativeFunction2Int32 = Int32 Function(Int32, Int32);
typedef NativeFunction4Int32 = Int32 Function(Int32, Int32, Int32, Int32);
typedef NativeFunction10Int32 =
    Int32 Function(
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
    );
typedef NativeFunction20Int32 =
    Int32 Function(
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
      Int32,
    );
typedef NativeFunction1Int64 = Int64 Function(Int64);
typedef NativeFunction2Int64 = Int64 Function(Int64, Int64);
typedef NativeFunction4Int64 = Int64 Function(Int64, Int64, Int64, Int64);
typedef NativeFunction10Int64 =
    Int64 Function(
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
    );
typedef NativeFunction20Int64 =
    Int64 Function(
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
      Int64,
    );
typedef NativeFunction1Uint8 = Uint8 Function(Uint8);
typedef NativeFunction2Uint8 = Uint8 Function(Uint8, Uint8);
typedef NativeFunction4Uint8 = Uint8 Function(Uint8, Uint8, Uint8, Uint8);
typedef NativeFunction10Uint8 =
    Uint8 Function(
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
    );
typedef NativeFunction20Uint8 =
    Uint8 Function(
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
      Uint8,
    );
typedef NativeFunction1Uint16 = Uint16 Function(Uint16);
typedef NativeFunction2Uint16 = Uint16 Function(Uint16, Uint16);
typedef NativeFunction4Uint16 = Uint16 Function(Uint16, Uint16, Uint16, Uint16);
typedef NativeFunction10Uint16 =
    Uint16 Function(
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
    );
typedef NativeFunction20Uint16 =
    Uint16 Function(
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
      Uint16,
    );
typedef NativeFunction1Uint32 = Uint32 Function(Uint32);
typedef NativeFunction2Uint32 = Uint32 Function(Uint32, Uint32);
typedef NativeFunction4Uint32 = Uint32 Function(Uint32, Uint32, Uint32, Uint32);
typedef NativeFunction10Uint32 =
    Uint32 Function(
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
    );
typedef NativeFunction20Uint32 =
    Uint32 Function(
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
      Uint32,
    );
typedef NativeFunction1Uint64 = Uint64 Function(Uint64);
typedef NativeFunction2Uint64 = Uint64 Function(Uint64, Uint64);
typedef NativeFunction4Uint64 = Uint64 Function(Uint64, Uint64, Uint64, Uint64);
typedef NativeFunction10Uint64 =
    Uint64 Function(
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
    );
typedef NativeFunction20Uint64 =
    Uint64 Function(
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
      Uint64,
    );
typedef NativeFunction1Float = Float Function(Float);
typedef NativeFunction2Float = Float Function(Float, Float);
typedef NativeFunction4Float = Float Function(Float, Float, Float, Float);
typedef NativeFunction10Float =
    Float Function(
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
    );
typedef NativeFunction20Float =
    Float Function(
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
      Float,
    );
typedef NativeFunction1Double = Double Function(Double);
typedef NativeFunction2Double = Double Function(Double, Double);
typedef NativeFunction4Double = Double Function(Double, Double, Double, Double);
typedef NativeFunction10Double =
    Double Function(
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
    );
typedef NativeFunction20Double =
    Double Function(
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
      Double,
    );
typedef NativeFunction1PointerUint8 = Pointer<Uint8> Function(Pointer<Uint8>);
typedef NativeFunction2PointerUint8 =
    Pointer<Uint8> Function(Pointer<Uint8>, Pointer<Uint8>);
typedef NativeFunction4PointerUint8 =
    Pointer<Uint8> Function(
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
    );
typedef NativeFunction10PointerUint8 =
    Pointer<Uint8> Function(
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
    );
typedef NativeFunction20PointerUint8 =
    Pointer<Uint8> Function(
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
      Pointer<Uint8>,
    );
typedef NativeFunction1Handle = Handle Function(Handle);
typedef NativeFunction2Handle = Handle Function(Handle, Handle);
typedef NativeFunction4Handle = Handle Function(Handle, Handle, Handle, Handle);
typedef NativeFunction10Handle =
    Handle Function(
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
    );
typedef NativeFunction20Handle =
    Handle Function(
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
      Handle,
    );

class Int8x01 extends FfiBenchmarkBase {
  final Function1int f;

  Int8x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction1Int8, Function1int>(
              'Function1Int8',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction1Int8, Function1int>(
              'Function1Int8',
              isLeaf: false,
            ),
      super('FfiCall.Int8x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Int8>(symbol: 'Function1Int8', isLeaf: false)
external int function1Int8(int a0);

class Int8x01Native extends FfiBenchmarkBase {
  Int8x01Native() : super('FfiCall.Int8x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int8(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Int8>(symbol: 'Function1Int8', isLeaf: true)
external int function1Int8Leaf(int a0);

class Int8x01NativeLeaf extends FfiBenchmarkBase {
  Int8x01NativeLeaf() : super('FfiCall.Int8x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int8Leaf(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

class Int16x01 extends FfiBenchmarkBase {
  final Function1int f;

  Int16x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction1Int16, Function1int>(
              'Function1Int16',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction1Int16, Function1int>(
              'Function1Int16',
              isLeaf: false,
            ),
      super('FfiCall.Int16x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Int16>(symbol: 'Function1Int16', isLeaf: false)
external int function1Int16(int a0);

class Int16x01Native extends FfiBenchmarkBase {
  Int16x01Native() : super('FfiCall.Int16x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int16(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Int16>(symbol: 'Function1Int16', isLeaf: true)
external int function1Int16Leaf(int a0);

class Int16x01NativeLeaf extends FfiBenchmarkBase {
  Int16x01NativeLeaf() : super('FfiCall.Int16x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int16Leaf(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

class Int32x01 extends FfiBenchmarkBase {
  final Function1int f;

  Int32x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction1Int32, Function1int>(
              'Function1Int32',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction1Int32, Function1int>(
              'Function1Int32',
              isLeaf: false,
            ),
      super('FfiCall.Int32x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Int32>(symbol: 'Function1Int32', isLeaf: false)
external int function1Int32(int a0);

class Int32x01Native extends FfiBenchmarkBase {
  Int32x01Native() : super('FfiCall.Int32x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int32(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Int32>(symbol: 'Function1Int32', isLeaf: true)
external int function1Int32Leaf(int a0);

class Int32x01NativeLeaf extends FfiBenchmarkBase {
  Int32x01NativeLeaf() : super('FfiCall.Int32x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int32Leaf(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

class Int32x02 extends FfiBenchmarkBase {
  final Function2int f;

  Int32x02({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction2Int32, Function2int>(
              'Function2Int32',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction2Int32, Function2int>(
              'Function2Int32',
              isLeaf: false,
            ),
      super('FfiCall.Int32x02', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i);
    }
    expectEquals(x, N * (N - 1) * 2 / 2);
  }
}

@Native<NativeFunction2Int32>(symbol: 'Function2Int32', isLeaf: false)
external int function2Int32(int a0, int a1);

class Int32x02Native extends FfiBenchmarkBase {
  Int32x02Native() : super('FfiCall.Int32x02Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function2Int32(i, i);
    }
    expectEquals(x, N * (N - 1) * 2 / 2);
  }
}

@Native<NativeFunction2Int32>(symbol: 'Function2Int32', isLeaf: true)
external int function2Int32Leaf(int a0, int a1);

class Int32x02NativeLeaf extends FfiBenchmarkBase {
  Int32x02NativeLeaf() : super('FfiCall.Int32x02Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function2Int32Leaf(i, i);
    }
    expectEquals(x, N * (N - 1) * 2 / 2);
  }
}

class Int32x04 extends FfiBenchmarkBase {
  final Function4int f;

  Int32x04({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction4Int32, Function4int>(
              'Function4Int32',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction4Int32, Function4int>(
              'Function4Int32',
              isLeaf: false,
            ),
      super('FfiCall.Int32x04', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 4 / 2);
  }
}

@Native<NativeFunction4Int32>(symbol: 'Function4Int32', isLeaf: false)
external int function4Int32(int a0, int a1, int a2, int a3);

class Int32x04Native extends FfiBenchmarkBase {
  Int32x04Native() : super('FfiCall.Int32x04Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function4Int32(i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 4 / 2);
  }
}

@Native<NativeFunction4Int32>(symbol: 'Function4Int32', isLeaf: true)
external int function4Int32Leaf(int a0, int a1, int a2, int a3);

class Int32x04NativeLeaf extends FfiBenchmarkBase {
  Int32x04NativeLeaf() : super('FfiCall.Int32x04Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function4Int32Leaf(i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 4 / 2);
  }
}

class Int32x10 extends FfiBenchmarkBase {
  final Function10int f;

  Int32x10({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction10Int32, Function10int>(
                  'Function10Int32',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction10Int32, Function10int>(
                  'Function10Int32',
                  isLeaf: false,
                ),
      super('FfiCall.Int32x10', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 10 / 2);
  }
}

@Native<NativeFunction10Int32>(symbol: 'Function10Int32', isLeaf: false)
external int function10Int32(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
);

class Int32x10Native extends FfiBenchmarkBase {
  Int32x10Native() : super('FfiCall.Int32x10Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function10Int32(i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 10 / 2);
  }
}

@Native<NativeFunction10Int32>(symbol: 'Function10Int32', isLeaf: true)
external int function10Int32Leaf(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
);

class Int32x10NativeLeaf extends FfiBenchmarkBase {
  Int32x10NativeLeaf() : super('FfiCall.Int32x10Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function10Int32Leaf(i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 10 / 2);
  }
}

class Int32x20 extends FfiBenchmarkBase {
  final Function20int f;

  Int32x20({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction20Int32, Function20int>(
                  'Function20Int32',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction20Int32, Function20int>(
                  'Function20Int32',
                  isLeaf: false,
                ),
      super('FfiCall.Int32x20', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 20 / 2);
  }
}

@Native<NativeFunction20Int32>(symbol: 'Function20Int32', isLeaf: false)
external int function20Int32(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
  int a10,
  int a11,
  int a12,
  int a13,
  int a14,
  int a15,
  int a16,
  int a17,
  int a18,
  int a19,
);

class Int32x20Native extends FfiBenchmarkBase {
  Int32x20Native() : super('FfiCall.Int32x20Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function20Int32(
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
      );
    }
    expectEquals(x, N * (N - 1) * 20 / 2);
  }
}

@Native<NativeFunction20Int32>(symbol: 'Function20Int32', isLeaf: true)
external int function20Int32Leaf(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
  int a10,
  int a11,
  int a12,
  int a13,
  int a14,
  int a15,
  int a16,
  int a17,
  int a18,
  int a19,
);

class Int32x20NativeLeaf extends FfiBenchmarkBase {
  Int32x20NativeLeaf() : super('FfiCall.Int32x20Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function20Int32Leaf(
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
      );
    }
    expectEquals(x, N * (N - 1) * 20 / 2);
  }
}

class Int64x01 extends FfiBenchmarkBase {
  final Function1int f;

  Int64x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction1Int64, Function1int>(
              'Function1Int64',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction1Int64, Function1int>(
              'Function1Int64',
              isLeaf: false,
            ),
      super('FfiCall.Int64x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Int64>(symbol: 'Function1Int64', isLeaf: false)
external int function1Int64(int a0);

class Int64x01Native extends FfiBenchmarkBase {
  Int64x01Native() : super('FfiCall.Int64x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int64(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Int64>(symbol: 'Function1Int64', isLeaf: true)
external int function1Int64Leaf(int a0);

class Int64x01NativeLeaf extends FfiBenchmarkBase {
  Int64x01NativeLeaf() : super('FfiCall.Int64x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Int64Leaf(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

class Int64x02 extends FfiBenchmarkBase {
  final Function2int f;

  Int64x02({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction2Int64, Function2int>(
              'Function2Int64',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction2Int64, Function2int>(
              'Function2Int64',
              isLeaf: false,
            ),
      super('FfiCall.Int64x02', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i);
    }
    expectEquals(x, N * (N - 1) * 2 / 2);
  }
}

@Native<NativeFunction2Int64>(symbol: 'Function2Int64', isLeaf: false)
external int function2Int64(int a0, int a1);

class Int64x02Native extends FfiBenchmarkBase {
  Int64x02Native() : super('FfiCall.Int64x02Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function2Int64(i, i);
    }
    expectEquals(x, N * (N - 1) * 2 / 2);
  }
}

@Native<NativeFunction2Int64>(symbol: 'Function2Int64', isLeaf: true)
external int function2Int64Leaf(int a0, int a1);

class Int64x02NativeLeaf extends FfiBenchmarkBase {
  Int64x02NativeLeaf() : super('FfiCall.Int64x02Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function2Int64Leaf(i, i);
    }
    expectEquals(x, N * (N - 1) * 2 / 2);
  }
}

class Int64x04 extends FfiBenchmarkBase {
  final Function4int f;

  Int64x04({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction4Int64, Function4int>(
              'Function4Int64',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction4Int64, Function4int>(
              'Function4Int64',
              isLeaf: false,
            ),
      super('FfiCall.Int64x04', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 4 / 2);
  }
}

@Native<NativeFunction4Int64>(symbol: 'Function4Int64', isLeaf: false)
external int function4Int64(int a0, int a1, int a2, int a3);

class Int64x04Native extends FfiBenchmarkBase {
  Int64x04Native() : super('FfiCall.Int64x04Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function4Int64(i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 4 / 2);
  }
}

@Native<NativeFunction4Int64>(symbol: 'Function4Int64', isLeaf: true)
external int function4Int64Leaf(int a0, int a1, int a2, int a3);

class Int64x04NativeLeaf extends FfiBenchmarkBase {
  Int64x04NativeLeaf() : super('FfiCall.Int64x04Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function4Int64Leaf(i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 4 / 2);
  }
}

class Int64x10 extends FfiBenchmarkBase {
  final Function10int f;

  Int64x10({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction10Int64, Function10int>(
                  'Function10Int64',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction10Int64, Function10int>(
                  'Function10Int64',
                  isLeaf: false,
                ),
      super('FfiCall.Int64x10', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 10 / 2);
  }
}

@Native<NativeFunction10Int64>(symbol: 'Function10Int64', isLeaf: false)
external int function10Int64(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
);

class Int64x10Native extends FfiBenchmarkBase {
  Int64x10Native() : super('FfiCall.Int64x10Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function10Int64(i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 10 / 2);
  }
}

@Native<NativeFunction10Int64>(symbol: 'Function10Int64', isLeaf: true)
external int function10Int64Leaf(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
);

class Int64x10NativeLeaf extends FfiBenchmarkBase {
  Int64x10NativeLeaf() : super('FfiCall.Int64x10Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function10Int64Leaf(i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 10 / 2);
  }
}

class Int64x20 extends FfiBenchmarkBase {
  final Function20int f;

  Int64x20({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction20Int64, Function20int>(
                  'Function20Int64',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction20Int64, Function20int>(
                  'Function20Int64',
                  isLeaf: false,
                ),
      super('FfiCall.Int64x20', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i);
    }
    expectEquals(x, N * (N - 1) * 20 / 2);
  }
}

@Native<NativeFunction20Int64>(symbol: 'Function20Int64', isLeaf: false)
external int function20Int64(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
  int a10,
  int a11,
  int a12,
  int a13,
  int a14,
  int a15,
  int a16,
  int a17,
  int a18,
  int a19,
);

class Int64x20Native extends FfiBenchmarkBase {
  Int64x20Native() : super('FfiCall.Int64x20Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function20Int64(
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
      );
    }
    expectEquals(x, N * (N - 1) * 20 / 2);
  }
}

@Native<NativeFunction20Int64>(symbol: 'Function20Int64', isLeaf: true)
external int function20Int64Leaf(
  int a0,
  int a1,
  int a2,
  int a3,
  int a4,
  int a5,
  int a6,
  int a7,
  int a8,
  int a9,
  int a10,
  int a11,
  int a12,
  int a13,
  int a14,
  int a15,
  int a16,
  int a17,
  int a18,
  int a19,
);

class Int64x20NativeLeaf extends FfiBenchmarkBase {
  Int64x20NativeLeaf() : super('FfiCall.Int64x20Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function20Int64Leaf(
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
        i,
      );
    }
    expectEquals(x, N * (N - 1) * 20 / 2);
  }
}

class Uint8x01 extends FfiBenchmarkBase {
  final Function1int f;

  Uint8x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<NativeFunction1Uint8, Function1int>(
              'Function1Uint8',
              isLeaf: true,
            )
          : ffiTestFunctions.lookupFunction<NativeFunction1Uint8, Function1int>(
              'Function1Uint8',
              isLeaf: false,
            ),
      super('FfiCall.Uint8x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Uint8>(symbol: 'Function1Uint8', isLeaf: false)
external int function1Uint8(int a0);

class Uint8x01Native extends FfiBenchmarkBase {
  Uint8x01Native() : super('FfiCall.Uint8x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint8(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Uint8>(symbol: 'Function1Uint8', isLeaf: true)
external int function1Uint8Leaf(int a0);

class Uint8x01NativeLeaf extends FfiBenchmarkBase {
  Uint8x01NativeLeaf() : super('FfiCall.Uint8x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint8Leaf(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

class Uint16x01 extends FfiBenchmarkBase {
  final Function1int f;

  Uint16x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction1Uint16, Function1int>(
                  'Function1Uint16',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction1Uint16, Function1int>(
                  'Function1Uint16',
                  isLeaf: false,
                ),
      super('FfiCall.Uint16x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Uint16>(symbol: 'Function1Uint16', isLeaf: false)
external int function1Uint16(int a0);

class Uint16x01Native extends FfiBenchmarkBase {
  Uint16x01Native() : super('FfiCall.Uint16x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint16(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

@Native<NativeFunction1Uint16>(symbol: 'Function1Uint16', isLeaf: true)
external int function1Uint16Leaf(int a0);

class Uint16x01NativeLeaf extends FfiBenchmarkBase {
  Uint16x01NativeLeaf() : super('FfiCall.Uint16x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint16Leaf(17);
    }
    expectEquals(x, N * 17 + N * 42);
  }
}

class Uint32x01 extends FfiBenchmarkBase {
  final Function1int f;

  Uint32x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction1Uint32, Function1int>(
                  'Function1Uint32',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction1Uint32, Function1int>(
                  'Function1Uint32',
                  isLeaf: false,
                ),
      super('FfiCall.Uint32x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Uint32>(symbol: 'Function1Uint32', isLeaf: false)
external int function1Uint32(int a0);

class Uint32x01Native extends FfiBenchmarkBase {
  Uint32x01Native() : super('FfiCall.Uint32x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint32(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Uint32>(symbol: 'Function1Uint32', isLeaf: true)
external int function1Uint32Leaf(int a0);

class Uint32x01NativeLeaf extends FfiBenchmarkBase {
  Uint32x01NativeLeaf() : super('FfiCall.Uint32x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint32Leaf(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

class Uint64x01 extends FfiBenchmarkBase {
  final Function1int f;

  Uint64x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction1Uint64, Function1int>(
                  'Function1Uint64',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction1Uint64, Function1int>(
                  'Function1Uint64',
                  isLeaf: false,
                ),
      super('FfiCall.Uint64x01', isLeaf: isLeaf);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += f(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Uint64>(symbol: 'Function1Uint64', isLeaf: false)
external int function1Uint64(int a0);

class Uint64x01Native extends FfiBenchmarkBase {
  Uint64x01Native() : super('FfiCall.Uint64x01Native', isLeaf: false);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint64(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

@Native<NativeFunction1Uint64>(symbol: 'Function1Uint64', isLeaf: true)
external int function1Uint64Leaf(int a0);

class Uint64x01NativeLeaf extends FfiBenchmarkBase {
  Uint64x01NativeLeaf() : super('FfiCall.Uint64x01Native', isLeaf: true);

  @override
  void run() {
    int x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Uint64Leaf(i);
    }
    expectEquals(x, N * (N - 1) / 2 + N * 42);
  }
}

class Floatx01 extends FfiBenchmarkBase {
  final Function1double f;

  Floatx01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction1Float, Function1double>(
                  'Function1Float',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction1Float, Function1double>(
                  'Function1Float',
                  isLeaf: false,
                ),
      super('FfiCall.Floatx01', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0);
    }
    final double expected = N + N * 42.0;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction1Float>(symbol: 'Function1Float', isLeaf: false)
external double function1Float(double a0);

class Floatx01Native extends FfiBenchmarkBase {
  Floatx01Native() : super('FfiCall.Floatx01Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Float(1.0);
    }
    final double expected = N + N * 42.0;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction1Float>(symbol: 'Function1Float', isLeaf: true)
external double function1FloatLeaf(double a0);

class Floatx01NativeLeaf extends FfiBenchmarkBase {
  Floatx01NativeLeaf() : super('FfiCall.Floatx01Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function1FloatLeaf(1.0);
    }
    final double expected = N + N * 42.0;
    expectApprox(x, expected);
  }
}

class Floatx02 extends FfiBenchmarkBase {
  final Function2double f;

  Floatx02({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction2Float, Function2double>(
                  'Function2Float',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction2Float, Function2double>(
                  'Function2Float',
                  isLeaf: false,
                ),
      super('FfiCall.Floatx02', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0, 2.0);
    }
    final double expected = N * 2 * (2 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction2Float>(symbol: 'Function2Float', isLeaf: false)
external double function2Float(double a0, double a1);

class Floatx02Native extends FfiBenchmarkBase {
  Floatx02Native() : super('FfiCall.Floatx02Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function2Float(1.0, 2.0);
    }
    final double expected = N * 2 * (2 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction2Float>(symbol: 'Function2Float', isLeaf: true)
external double function2FloatLeaf(double a0, double a1);

class Floatx02NativeLeaf extends FfiBenchmarkBase {
  Floatx02NativeLeaf() : super('FfiCall.Floatx02Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function2FloatLeaf(1.0, 2.0);
    }
    final double expected = N * 2 * (2 + 1) / 2;
    expectApprox(x, expected);
  }
}

class Floatx04 extends FfiBenchmarkBase {
  final Function4double f;

  Floatx04({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction4Float, Function4double>(
                  'Function4Float',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction4Float, Function4double>(
                  'Function4Float',
                  isLeaf: false,
                ),
      super('FfiCall.Floatx04', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0, 2.0, 3.0, 4.0);
    }
    final double expected = N * 4 * (4 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction4Float>(symbol: 'Function4Float', isLeaf: false)
external double function4Float(double a0, double a1, double a2, double a3);

class Floatx04Native extends FfiBenchmarkBase {
  Floatx04Native() : super('FfiCall.Floatx04Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function4Float(1.0, 2.0, 3.0, 4.0);
    }
    final double expected = N * 4 * (4 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction4Float>(symbol: 'Function4Float', isLeaf: true)
external double function4FloatLeaf(double a0, double a1, double a2, double a3);

class Floatx04NativeLeaf extends FfiBenchmarkBase {
  Floatx04NativeLeaf() : super('FfiCall.Floatx04Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function4FloatLeaf(1.0, 2.0, 3.0, 4.0);
    }
    final double expected = N * 4 * (4 + 1) / 2;
    expectApprox(x, expected);
  }
}

class Floatx10 extends FfiBenchmarkBase {
  final Function10double f;

  Floatx10({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction10Float, Function10double>(
                  'Function10Float',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction10Float, Function10double>(
                  'Function10Float',
                  isLeaf: false,
                ),
      super('FfiCall.Floatx10', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);
    }
    final double expected = N * 10 * (10 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction10Float>(symbol: 'Function10Float', isLeaf: false)
external double function10Float(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
);

class Floatx10Native extends FfiBenchmarkBase {
  Floatx10Native() : super('FfiCall.Floatx10Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function10Float(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);
    }
    final double expected = N * 10 * (10 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction10Float>(symbol: 'Function10Float', isLeaf: true)
external double function10FloatLeaf(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
);

class Floatx10NativeLeaf extends FfiBenchmarkBase {
  Floatx10NativeLeaf() : super('FfiCall.Floatx10Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function10FloatLeaf(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
      );
    }
    final double expected = N * 10 * (10 + 1) / 2;
    expectApprox(x, expected);
  }
}

class Floatx20 extends FfiBenchmarkBase {
  final Function20double f;

  Floatx20({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction20Float, Function20double>(
                  'Function20Float',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction20Float, Function20double>(
                  'Function20Float',
                  isLeaf: false,
                ),
      super('FfiCall.Floatx20', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
        11.0,
        12.0,
        13.0,
        14.0,
        15.0,
        16.0,
        17.0,
        18.0,
        19.0,
        20.0,
      );
    }
    final double expected = N * 20 * (20 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction20Float>(symbol: 'Function20Float', isLeaf: false)
external double function20Float(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
  double a10,
  double a11,
  double a12,
  double a13,
  double a14,
  double a15,
  double a16,
  double a17,
  double a18,
  double a19,
);

class Floatx20Native extends FfiBenchmarkBase {
  Floatx20Native() : super('FfiCall.Floatx20Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function20Float(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
        11.0,
        12.0,
        13.0,
        14.0,
        15.0,
        16.0,
        17.0,
        18.0,
        19.0,
        20.0,
      );
    }
    final double expected = N * 20 * (20 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction20Float>(symbol: 'Function20Float', isLeaf: true)
external double function20FloatLeaf(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
  double a10,
  double a11,
  double a12,
  double a13,
  double a14,
  double a15,
  double a16,
  double a17,
  double a18,
  double a19,
);

class Floatx20NativeLeaf extends FfiBenchmarkBase {
  Floatx20NativeLeaf() : super('FfiCall.Floatx20Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function20FloatLeaf(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
        11.0,
        12.0,
        13.0,
        14.0,
        15.0,
        16.0,
        17.0,
        18.0,
        19.0,
        20.0,
      );
    }
    final double expected = N * 20 * (20 + 1) / 2;
    expectApprox(x, expected);
  }
}

class Doublex01 extends FfiBenchmarkBase {
  final Function1double f;

  Doublex01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction1Double, Function1double>(
                  'Function1Double',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction1Double, Function1double>(
                  'Function1Double',
                  isLeaf: false,
                ),
      super('FfiCall.Doublex01', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0);
    }
    final double expected = N + N * 42.0;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction1Double>(symbol: 'Function1Double', isLeaf: false)
external double function1Double(double a0);

class Doublex01Native extends FfiBenchmarkBase {
  Doublex01Native() : super('FfiCall.Doublex01Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function1Double(1.0);
    }
    final double expected = N + N * 42.0;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction1Double>(symbol: 'Function1Double', isLeaf: true)
external double function1DoubleLeaf(double a0);

class Doublex01NativeLeaf extends FfiBenchmarkBase {
  Doublex01NativeLeaf() : super('FfiCall.Doublex01Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function1DoubleLeaf(1.0);
    }
    final double expected = N + N * 42.0;
    expectApprox(x, expected);
  }
}

class Doublex02 extends FfiBenchmarkBase {
  final Function2double f;

  Doublex02({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction2Double, Function2double>(
                  'Function2Double',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction2Double, Function2double>(
                  'Function2Double',
                  isLeaf: false,
                ),
      super('FfiCall.Doublex02', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0, 2.0);
    }
    final double expected = N * 2 * (2 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction2Double>(symbol: 'Function2Double', isLeaf: false)
external double function2Double(double a0, double a1);

class Doublex02Native extends FfiBenchmarkBase {
  Doublex02Native() : super('FfiCall.Doublex02Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function2Double(1.0, 2.0);
    }
    final double expected = N * 2 * (2 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction2Double>(symbol: 'Function2Double', isLeaf: true)
external double function2DoubleLeaf(double a0, double a1);

class Doublex02NativeLeaf extends FfiBenchmarkBase {
  Doublex02NativeLeaf() : super('FfiCall.Doublex02Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function2DoubleLeaf(1.0, 2.0);
    }
    final double expected = N * 2 * (2 + 1) / 2;
    expectApprox(x, expected);
  }
}

class Doublex04 extends FfiBenchmarkBase {
  final Function4double f;

  Doublex04({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction4Double, Function4double>(
                  'Function4Double',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction4Double, Function4double>(
                  'Function4Double',
                  isLeaf: false,
                ),
      super('FfiCall.Doublex04', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0, 2.0, 3.0, 4.0);
    }
    final double expected = N * 4 * (4 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction4Double>(symbol: 'Function4Double', isLeaf: false)
external double function4Double(double a0, double a1, double a2, double a3);

class Doublex04Native extends FfiBenchmarkBase {
  Doublex04Native() : super('FfiCall.Doublex04Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function4Double(1.0, 2.0, 3.0, 4.0);
    }
    final double expected = N * 4 * (4 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction4Double>(symbol: 'Function4Double', isLeaf: true)
external double function4DoubleLeaf(double a0, double a1, double a2, double a3);

class Doublex04NativeLeaf extends FfiBenchmarkBase {
  Doublex04NativeLeaf() : super('FfiCall.Doublex04Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function4DoubleLeaf(1.0, 2.0, 3.0, 4.0);
    }
    final double expected = N * 4 * (4 + 1) / 2;
    expectApprox(x, expected);
  }
}

class Doublex10 extends FfiBenchmarkBase {
  final Function10double f;

  Doublex10({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction10Double, Function10double>(
                  'Function10Double',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction10Double, Function10double>(
                  'Function10Double',
                  isLeaf: false,
                ),
      super('FfiCall.Doublex10', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);
    }
    final double expected = N * 10 * (10 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction10Double>(symbol: 'Function10Double', isLeaf: false)
external double function10Double(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
);

class Doublex10Native extends FfiBenchmarkBase {
  Doublex10Native() : super('FfiCall.Doublex10Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function10Double(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);
    }
    final double expected = N * 10 * (10 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction10Double>(symbol: 'Function10Double', isLeaf: true)
external double function10DoubleLeaf(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
);

class Doublex10NativeLeaf extends FfiBenchmarkBase {
  Doublex10NativeLeaf() : super('FfiCall.Doublex10Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function10DoubleLeaf(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
      );
    }
    final double expected = N * 10 * (10 + 1) / 2;
    expectApprox(x, expected);
  }
}

class Doublex20 extends FfiBenchmarkBase {
  final Function20double f;

  Doublex20({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions
                .lookupFunction<NativeFunction20Double, Function20double>(
                  'Function20Double',
                  isLeaf: true,
                )
          : ffiTestFunctions
                .lookupFunction<NativeFunction20Double, Function20double>(
                  'Function20Double',
                  isLeaf: false,
                ),
      super('FfiCall.Doublex20', isLeaf: isLeaf);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += f(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
        11.0,
        12.0,
        13.0,
        14.0,
        15.0,
        16.0,
        17.0,
        18.0,
        19.0,
        20.0,
      );
    }
    final double expected = N * 20 * (20 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction20Double>(symbol: 'Function20Double', isLeaf: false)
external double function20Double(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
  double a10,
  double a11,
  double a12,
  double a13,
  double a14,
  double a15,
  double a16,
  double a17,
  double a18,
  double a19,
);

class Doublex20Native extends FfiBenchmarkBase {
  Doublex20Native() : super('FfiCall.Doublex20Native', isLeaf: false);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function20Double(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
        11.0,
        12.0,
        13.0,
        14.0,
        15.0,
        16.0,
        17.0,
        18.0,
        19.0,
        20.0,
      );
    }
    final double expected = N * 20 * (20 + 1) / 2;
    expectApprox(x, expected);
  }
}

@Native<NativeFunction20Double>(symbol: 'Function20Double', isLeaf: true)
external double function20DoubleLeaf(
  double a0,
  double a1,
  double a2,
  double a3,
  double a4,
  double a5,
  double a6,
  double a7,
  double a8,
  double a9,
  double a10,
  double a11,
  double a12,
  double a13,
  double a14,
  double a15,
  double a16,
  double a17,
  double a18,
  double a19,
);

class Doublex20NativeLeaf extends FfiBenchmarkBase {
  Doublex20NativeLeaf() : super('FfiCall.Doublex20Native', isLeaf: true);

  @override
  void run() {
    double x = 0;
    for (int i = 0; i < N; i++) {
      x += function20DoubleLeaf(
        1.0,
        2.0,
        3.0,
        4.0,
        5.0,
        6.0,
        7.0,
        8.0,
        9.0,
        10.0,
        11.0,
        12.0,
        13.0,
        14.0,
        15.0,
        16.0,
        17.0,
        18.0,
        19.0,
        20.0,
      );
    }
    final double expected = N * 20 * (20 + 1) / 2;
    expectApprox(x, expected);
  }
}

class PointerUint8x01 extends FfiBenchmarkBase {
  final Function1PointerUint8 f;

  PointerUint8x01({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<
              NativeFunction1PointerUint8,
              Function1PointerUint8
            >('Function1PointerUint8', isLeaf: true)
          : ffiTestFunctions.lookupFunction<
              NativeFunction1PointerUint8,
              Function1PointerUint8
            >('Function1PointerUint8', isLeaf: false),
      super('FfiCall.PointerUint8x01', isLeaf: isLeaf);

  Pointer<Uint8> p1 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = f(x);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction1PointerUint8>(
  symbol: 'Function1PointerUint8',
  isLeaf: false,
)
external Pointer<Uint8> function1PointerUint8(Pointer<Uint8> a0);

class PointerUint8x01Native extends FfiBenchmarkBase {
  PointerUint8x01Native()
    : super('FfiCall.PointerUint8x01Native', isLeaf: false);

  Pointer<Uint8> p1 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function1PointerUint8(x);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction1PointerUint8>(
  symbol: 'Function1PointerUint8',
  isLeaf: true,
)
external Pointer<Uint8> function1PointerUint8Leaf(Pointer<Uint8> a0);

class PointerUint8x01NativeLeaf extends FfiBenchmarkBase {
  PointerUint8x01NativeLeaf()
    : super('FfiCall.PointerUint8x01Native', isLeaf: true);

  Pointer<Uint8> p1 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function1PointerUint8Leaf(x);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

class PointerUint8x02 extends FfiBenchmarkBase {
  final Function2PointerUint8 f;

  PointerUint8x02({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<
              NativeFunction2PointerUint8,
              Function2PointerUint8
            >('Function2PointerUint8', isLeaf: true)
          : ffiTestFunctions.lookupFunction<
              NativeFunction2PointerUint8,
              Function2PointerUint8
            >('Function2PointerUint8', isLeaf: false),
      super('FfiCall.PointerUint8x02', isLeaf: isLeaf);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = f(x, p2);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction2PointerUint8>(
  symbol: 'Function2PointerUint8',
  isLeaf: false,
)
external Pointer<Uint8> function2PointerUint8(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
);

class PointerUint8x02Native extends FfiBenchmarkBase {
  PointerUint8x02Native()
    : super('FfiCall.PointerUint8x02Native', isLeaf: false);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function2PointerUint8(x, p2);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction2PointerUint8>(
  symbol: 'Function2PointerUint8',
  isLeaf: true,
)
external Pointer<Uint8> function2PointerUint8Leaf(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
);

class PointerUint8x02NativeLeaf extends FfiBenchmarkBase {
  PointerUint8x02NativeLeaf()
    : super('FfiCall.PointerUint8x02Native', isLeaf: true);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function2PointerUint8Leaf(x, p2);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

class PointerUint8x04 extends FfiBenchmarkBase {
  final Function4PointerUint8 f;

  PointerUint8x04({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<
              NativeFunction4PointerUint8,
              Function4PointerUint8
            >('Function4PointerUint8', isLeaf: true)
          : ffiTestFunctions.lookupFunction<
              NativeFunction4PointerUint8,
              Function4PointerUint8
            >('Function4PointerUint8', isLeaf: false),
      super('FfiCall.PointerUint8x04', isLeaf: isLeaf);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = f(x, p2, p3, p4);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction4PointerUint8>(
  symbol: 'Function4PointerUint8',
  isLeaf: false,
)
external Pointer<Uint8> function4PointerUint8(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
  Pointer<Uint8> a2,
  Pointer<Uint8> a3,
);

class PointerUint8x04Native extends FfiBenchmarkBase {
  PointerUint8x04Native()
    : super('FfiCall.PointerUint8x04Native', isLeaf: false);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function4PointerUint8(x, p2, p3, p4);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction4PointerUint8>(
  symbol: 'Function4PointerUint8',
  isLeaf: true,
)
external Pointer<Uint8> function4PointerUint8Leaf(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
  Pointer<Uint8> a2,
  Pointer<Uint8> a3,
);

class PointerUint8x04NativeLeaf extends FfiBenchmarkBase {
  PointerUint8x04NativeLeaf()
    : super('FfiCall.PointerUint8x04Native', isLeaf: true);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function4PointerUint8Leaf(x, p2, p3, p4);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

class PointerUint8x10 extends FfiBenchmarkBase {
  final Function10PointerUint8 f;

  PointerUint8x10({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<
              NativeFunction10PointerUint8,
              Function10PointerUint8
            >('Function10PointerUint8', isLeaf: true)
          : ffiTestFunctions.lookupFunction<
              NativeFunction10PointerUint8,
              Function10PointerUint8
            >('Function10PointerUint8', isLeaf: false),
      super('FfiCall.PointerUint8x10', isLeaf: isLeaf);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;
  Pointer<Uint8> p5 = nullptr;
  Pointer<Uint8> p6 = nullptr;
  Pointer<Uint8> p7 = nullptr;
  Pointer<Uint8> p8 = nullptr;
  Pointer<Uint8> p9 = nullptr;
  Pointer<Uint8> p10 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
    p5 = p1 + 4;
    p6 = p1 + 5;
    p7 = p1 + 6;
    p8 = p1 + 7;
    p9 = p1 + 8;
    p10 = p1 + 9;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = f(x, p2, p3, p4, p5, p6, p7, p8, p9, p10);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction10PointerUint8>(
  symbol: 'Function10PointerUint8',
  isLeaf: false,
)
external Pointer<Uint8> function10PointerUint8(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
  Pointer<Uint8> a2,
  Pointer<Uint8> a3,
  Pointer<Uint8> a4,
  Pointer<Uint8> a5,
  Pointer<Uint8> a6,
  Pointer<Uint8> a7,
  Pointer<Uint8> a8,
  Pointer<Uint8> a9,
);

class PointerUint8x10Native extends FfiBenchmarkBase {
  PointerUint8x10Native()
    : super('FfiCall.PointerUint8x10Native', isLeaf: false);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;
  Pointer<Uint8> p5 = nullptr;
  Pointer<Uint8> p6 = nullptr;
  Pointer<Uint8> p7 = nullptr;
  Pointer<Uint8> p8 = nullptr;
  Pointer<Uint8> p9 = nullptr;
  Pointer<Uint8> p10 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
    p5 = p1 + 4;
    p6 = p1 + 5;
    p7 = p1 + 6;
    p8 = p1 + 7;
    p9 = p1 + 8;
    p10 = p1 + 9;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function10PointerUint8(x, p2, p3, p4, p5, p6, p7, p8, p9, p10);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction10PointerUint8>(
  symbol: 'Function10PointerUint8',
  isLeaf: true,
)
external Pointer<Uint8> function10PointerUint8Leaf(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
  Pointer<Uint8> a2,
  Pointer<Uint8> a3,
  Pointer<Uint8> a4,
  Pointer<Uint8> a5,
  Pointer<Uint8> a6,
  Pointer<Uint8> a7,
  Pointer<Uint8> a8,
  Pointer<Uint8> a9,
);

class PointerUint8x10NativeLeaf extends FfiBenchmarkBase {
  PointerUint8x10NativeLeaf()
    : super('FfiCall.PointerUint8x10Native', isLeaf: true);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;
  Pointer<Uint8> p5 = nullptr;
  Pointer<Uint8> p6 = nullptr;
  Pointer<Uint8> p7 = nullptr;
  Pointer<Uint8> p8 = nullptr;
  Pointer<Uint8> p9 = nullptr;
  Pointer<Uint8> p10 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
    p5 = p1 + 4;
    p6 = p1 + 5;
    p7 = p1 + 6;
    p8 = p1 + 7;
    p9 = p1 + 8;
    p10 = p1 + 9;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function10PointerUint8Leaf(x, p2, p3, p4, p5, p6, p7, p8, p9, p10);
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

class PointerUint8x20 extends FfiBenchmarkBase {
  final Function20PointerUint8 f;

  PointerUint8x20({bool isLeaf = false})
    : f = isLeaf
          ? ffiTestFunctions.lookupFunction<
              NativeFunction20PointerUint8,
              Function20PointerUint8
            >('Function20PointerUint8', isLeaf: true)
          : ffiTestFunctions.lookupFunction<
              NativeFunction20PointerUint8,
              Function20PointerUint8
            >('Function20PointerUint8', isLeaf: false),
      super('FfiCall.PointerUint8x20', isLeaf: isLeaf);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;
  Pointer<Uint8> p5 = nullptr;
  Pointer<Uint8> p6 = nullptr;
  Pointer<Uint8> p7 = nullptr;
  Pointer<Uint8> p8 = nullptr;
  Pointer<Uint8> p9 = nullptr;
  Pointer<Uint8> p10 = nullptr;
  Pointer<Uint8> p11 = nullptr;
  Pointer<Uint8> p12 = nullptr;
  Pointer<Uint8> p13 = nullptr;
  Pointer<Uint8> p14 = nullptr;
  Pointer<Uint8> p15 = nullptr;
  Pointer<Uint8> p16 = nullptr;
  Pointer<Uint8> p17 = nullptr;
  Pointer<Uint8> p18 = nullptr;
  Pointer<Uint8> p19 = nullptr;
  Pointer<Uint8> p20 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
    p5 = p1 + 4;
    p6 = p1 + 5;
    p7 = p1 + 6;
    p8 = p1 + 7;
    p9 = p1 + 8;
    p10 = p1 + 9;
    p11 = p1 + 10;
    p12 = p1 + 11;
    p13 = p1 + 12;
    p14 = p1 + 13;
    p15 = p1 + 14;
    p16 = p1 + 15;
    p17 = p1 + 16;
    p18 = p1 + 17;
    p19 = p1 + 18;
    p20 = p1 + 19;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = f(
        x,
        p2,
        p3,
        p4,
        p5,
        p6,
        p7,
        p8,
        p9,
        p10,
        p11,
        p12,
        p13,
        p14,
        p15,
        p16,
        p17,
        p18,
        p19,
        p20,
      );
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction20PointerUint8>(
  symbol: 'Function20PointerUint8',
  isLeaf: false,
)
external Pointer<Uint8> function20PointerUint8(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
  Pointer<Uint8> a2,
  Pointer<Uint8> a3,
  Pointer<Uint8> a4,
  Pointer<Uint8> a5,
  Pointer<Uint8> a6,
  Pointer<Uint8> a7,
  Pointer<Uint8> a8,
  Pointer<Uint8> a9,
  Pointer<Uint8> a10,
  Pointer<Uint8> a11,
  Pointer<Uint8> a12,
  Pointer<Uint8> a13,
  Pointer<Uint8> a14,
  Pointer<Uint8> a15,
  Pointer<Uint8> a16,
  Pointer<Uint8> a17,
  Pointer<Uint8> a18,
  Pointer<Uint8> a19,
);

class PointerUint8x20Native extends FfiBenchmarkBase {
  PointerUint8x20Native()
    : super('FfiCall.PointerUint8x20Native', isLeaf: false);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;
  Pointer<Uint8> p5 = nullptr;
  Pointer<Uint8> p6 = nullptr;
  Pointer<Uint8> p7 = nullptr;
  Pointer<Uint8> p8 = nullptr;
  Pointer<Uint8> p9 = nullptr;
  Pointer<Uint8> p10 = nullptr;
  Pointer<Uint8> p11 = nullptr;
  Pointer<Uint8> p12 = nullptr;
  Pointer<Uint8> p13 = nullptr;
  Pointer<Uint8> p14 = nullptr;
  Pointer<Uint8> p15 = nullptr;
  Pointer<Uint8> p16 = nullptr;
  Pointer<Uint8> p17 = nullptr;
  Pointer<Uint8> p18 = nullptr;
  Pointer<Uint8> p19 = nullptr;
  Pointer<Uint8> p20 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
    p5 = p1 + 4;
    p6 = p1 + 5;
    p7 = p1 + 6;
    p8 = p1 + 7;
    p9 = p1 + 8;
    p10 = p1 + 9;
    p11 = p1 + 10;
    p12 = p1 + 11;
    p13 = p1 + 12;
    p14 = p1 + 13;
    p15 = p1 + 14;
    p16 = p1 + 15;
    p17 = p1 + 16;
    p18 = p1 + 17;
    p19 = p1 + 18;
    p20 = p1 + 19;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function20PointerUint8(
        x,
        p2,
        p3,
        p4,
        p5,
        p6,
        p7,
        p8,
        p9,
        p10,
        p11,
        p12,
        p13,
        p14,
        p15,
        p16,
        p17,
        p18,
        p19,
        p20,
      );
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

@Native<NativeFunction20PointerUint8>(
  symbol: 'Function20PointerUint8',
  isLeaf: true,
)
external Pointer<Uint8> function20PointerUint8Leaf(
  Pointer<Uint8> a0,
  Pointer<Uint8> a1,
  Pointer<Uint8> a2,
  Pointer<Uint8> a3,
  Pointer<Uint8> a4,
  Pointer<Uint8> a5,
  Pointer<Uint8> a6,
  Pointer<Uint8> a7,
  Pointer<Uint8> a8,
  Pointer<Uint8> a9,
  Pointer<Uint8> a10,
  Pointer<Uint8> a11,
  Pointer<Uint8> a12,
  Pointer<Uint8> a13,
  Pointer<Uint8> a14,
  Pointer<Uint8> a15,
  Pointer<Uint8> a16,
  Pointer<Uint8> a17,
  Pointer<Uint8> a18,
  Pointer<Uint8> a19,
);

class PointerUint8x20NativeLeaf extends FfiBenchmarkBase {
  PointerUint8x20NativeLeaf()
    : super('FfiCall.PointerUint8x20Native', isLeaf: true);

  Pointer<Uint8> p1 = nullptr;
  Pointer<Uint8> p2 = nullptr;
  Pointer<Uint8> p3 = nullptr;
  Pointer<Uint8> p4 = nullptr;
  Pointer<Uint8> p5 = nullptr;
  Pointer<Uint8> p6 = nullptr;
  Pointer<Uint8> p7 = nullptr;
  Pointer<Uint8> p8 = nullptr;
  Pointer<Uint8> p9 = nullptr;
  Pointer<Uint8> p10 = nullptr;
  Pointer<Uint8> p11 = nullptr;
  Pointer<Uint8> p12 = nullptr;
  Pointer<Uint8> p13 = nullptr;
  Pointer<Uint8> p14 = nullptr;
  Pointer<Uint8> p15 = nullptr;
  Pointer<Uint8> p16 = nullptr;
  Pointer<Uint8> p17 = nullptr;
  Pointer<Uint8> p18 = nullptr;
  Pointer<Uint8> p19 = nullptr;
  Pointer<Uint8> p20 = nullptr;

  @override
  void setup() {
    p1 = calloc(N + 1);
    p2 = p1 + 1;
    p3 = p1 + 2;
    p4 = p1 + 3;
    p5 = p1 + 4;
    p6 = p1 + 5;
    p7 = p1 + 6;
    p8 = p1 + 7;
    p9 = p1 + 8;
    p10 = p1 + 9;
    p11 = p1 + 10;
    p12 = p1 + 11;
    p13 = p1 + 12;
    p14 = p1 + 13;
    p15 = p1 + 14;
    p16 = p1 + 15;
    p17 = p1 + 16;
    p18 = p1 + 17;
    p19 = p1 + 18;
    p20 = p1 + 19;
  }

  @override
  void teardown() {
    calloc.free(p1);
  }

  @override
  void run() {
    Pointer<Uint8> x = p1;
    for (int i = 0; i < N; i++) {
      x = function20PointerUint8Leaf(
        x,
        p2,
        p3,
        p4,
        p5,
        p6,
        p7,
        p8,
        p9,
        p10,
        p11,
        p12,
        p13,
        p14,
        p15,
        p16,
        p17,
        p18,
        p19,
        p20,
      );
    }
    expectEquals(x.address, p1.address + N * sizeOf<Uint8>());
  }
}

class Handlex01 extends FfiBenchmarkBase {
  final Function1Object f;

  Handlex01()
    : f = ffiTestFunctions
          .lookupFunction<NativeFunction1Handle, Function1Object>(
            'Function1Handle',
            isLeaf: false,
          ),
      super('FfiCall.Handlex01', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);

    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = f(x);
    }
    expectIdentical(x, m1);
  }
}

@Native<NativeFunction1Handle>(symbol: 'Function1Handle', isLeaf: false)
external Object function1Handle(Object a0);

class Handlex01Native extends FfiBenchmarkBase {
  Handlex01Native() : super('FfiCall.Handlex01Native', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);

    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = function1Handle(x);
    }
    expectIdentical(x, m1);
  }
}

class Handlex02 extends FfiBenchmarkBase {
  final Function2Object f;

  Handlex02()
    : f = ffiTestFunctions
          .lookupFunction<NativeFunction2Handle, Function2Object>(
            'Function2Handle',
            isLeaf: false,
          ),
      super('FfiCall.Handlex02', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = f(x, m2);
    }
    expectIdentical(x, m1);
  }
}

@Native<NativeFunction2Handle>(symbol: 'Function2Handle', isLeaf: false)
external Object function2Handle(Object a0, Object a1);

class Handlex02Native extends FfiBenchmarkBase {
  Handlex02Native() : super('FfiCall.Handlex02Native', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = function2Handle(x, m2);
    }
    expectIdentical(x, m1);
  }
}

class Handlex04 extends FfiBenchmarkBase {
  final Function4Object f;

  Handlex04()
    : f = ffiTestFunctions
          .lookupFunction<NativeFunction4Handle, Function4Object>(
            'Function4Handle',
            isLeaf: false,
          ),
      super('FfiCall.Handlex04', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    final m3 = MyClass(3);
    final m4 = MyClass(4);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = f(x, m2, m3, m4);
    }
    expectIdentical(x, m1);
  }
}

@Native<NativeFunction4Handle>(symbol: 'Function4Handle', isLeaf: false)
external Object function4Handle(Object a0, Object a1, Object a2, Object a3);

class Handlex04Native extends FfiBenchmarkBase {
  Handlex04Native() : super('FfiCall.Handlex04Native', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    final m3 = MyClass(3);
    final m4 = MyClass(4);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = function4Handle(x, m2, m3, m4);
    }
    expectIdentical(x, m1);
  }
}

class Handlex10 extends FfiBenchmarkBase {
  final Function10Object f;

  Handlex10()
    : f = ffiTestFunctions
          .lookupFunction<NativeFunction10Handle, Function10Object>(
            'Function10Handle',
            isLeaf: false,
          ),
      super('FfiCall.Handlex10', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    final m3 = MyClass(3);
    final m4 = MyClass(4);
    final m5 = MyClass(5);
    final m6 = MyClass(6);
    final m7 = MyClass(7);
    final m8 = MyClass(8);
    final m9 = MyClass(9);
    final m10 = MyClass(10);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = f(x, m2, m3, m4, m5, m6, m7, m8, m9, m10);
    }
    expectIdentical(x, m1);
  }
}

@Native<NativeFunction10Handle>(symbol: 'Function10Handle', isLeaf: false)
external Object function10Handle(
  Object a0,
  Object a1,
  Object a2,
  Object a3,
  Object a4,
  Object a5,
  Object a6,
  Object a7,
  Object a8,
  Object a9,
);

class Handlex10Native extends FfiBenchmarkBase {
  Handlex10Native() : super('FfiCall.Handlex10Native', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    final m3 = MyClass(3);
    final m4 = MyClass(4);
    final m5 = MyClass(5);
    final m6 = MyClass(6);
    final m7 = MyClass(7);
    final m8 = MyClass(8);
    final m9 = MyClass(9);
    final m10 = MyClass(10);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = function10Handle(x, m2, m3, m4, m5, m6, m7, m8, m9, m10);
    }
    expectIdentical(x, m1);
  }
}

class Handlex20 extends FfiBenchmarkBase {
  final Function20Object f;

  Handlex20()
    : f = ffiTestFunctions
          .lookupFunction<NativeFunction20Handle, Function20Object>(
            'Function20Handle',
            isLeaf: false,
          ),
      super('FfiCall.Handlex20', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    final m3 = MyClass(3);
    final m4 = MyClass(4);
    final m5 = MyClass(5);
    final m6 = MyClass(6);
    final m7 = MyClass(7);
    final m8 = MyClass(8);
    final m9 = MyClass(9);
    final m10 = MyClass(10);
    final m11 = MyClass(11);
    final m12 = MyClass(12);
    final m13 = MyClass(13);
    final m14 = MyClass(14);
    final m15 = MyClass(15);
    final m16 = MyClass(16);
    final m17 = MyClass(17);
    final m18 = MyClass(18);
    final m19 = MyClass(19);
    final m20 = MyClass(20);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = f(
        x,
        m2,
        m3,
        m4,
        m5,
        m6,
        m7,
        m8,
        m9,
        m10,
        m11,
        m12,
        m13,
        m14,
        m15,
        m16,
        m17,
        m18,
        m19,
        m20,
      );
    }
    expectIdentical(x, m1);
  }
}

@Native<NativeFunction20Handle>(symbol: 'Function20Handle', isLeaf: false)
external Object function20Handle(
  Object a0,
  Object a1,
  Object a2,
  Object a3,
  Object a4,
  Object a5,
  Object a6,
  Object a7,
  Object a8,
  Object a9,
  Object a10,
  Object a11,
  Object a12,
  Object a13,
  Object a14,
  Object a15,
  Object a16,
  Object a17,
  Object a18,
  Object a19,
);

class Handlex20Native extends FfiBenchmarkBase {
  Handlex20Native() : super('FfiCall.Handlex20Native', isLeaf: false);

  @override
  void run() {
    final m1 = MyClass(123);
    final m2 = MyClass(2);
    final m3 = MyClass(3);
    final m4 = MyClass(4);
    final m5 = MyClass(5);
    final m6 = MyClass(6);
    final m7 = MyClass(7);
    final m8 = MyClass(8);
    final m9 = MyClass(9);
    final m10 = MyClass(10);
    final m11 = MyClass(11);
    final m12 = MyClass(12);
    final m13 = MyClass(13);
    final m14 = MyClass(14);
    final m15 = MyClass(15);
    final m16 = MyClass(16);
    final m17 = MyClass(17);
    final m18 = MyClass(18);
    final m19 = MyClass(19);
    final m20 = MyClass(20);
    Object x = m1;
    for (int i = 0; i < N; i++) {
      x = function20Handle(
        x,
        m2,
        m3,
        m4,
        m5,
        m6,
        m7,
        m8,
        m9,
        m10,
        m11,
        m12,
        m13,
        m14,
        m15,
        m16,
        m17,
        m18,
        m19,
        m20,
      );
    }
    expectIdentical(x, m1);
  }
}