// 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.
// Generated by tests/ffi/generator/structs_by_value_tests_generator.dart.
//
// SharedObjects=ffi_test_functions
// VMOptions=
// VMOptions=--deterministic --optimization-counter-threshold=90
// VMOptions=--use-slow-path
// VMOptions=--use-slow-path --stacktrace-every=100

import 'dart:ffi';

import 'package:expect/expect.dart';
// ignore: unused_import
import 'package:ffi/ffi.dart';

import 'dylib_utils.dart';

// Reuse the compound classes.
import 'function_structs_by_value_generated_compounds.dart';

final ffiTestFunctions = dlopenPlatformSpecific("ffi_test_functions");
void main() {
  // Force dlopen so @Native lookups in DynamicLibrary.process() succeed.
  dlopenGlobalPlatformSpecific('ffi_test_functions');

  for (int i = 0; i < 100; ++i) {
    testReturnStruct1ByteIntNativeLeaf();
    testReturnStruct3BytesHomogeneousUint8NativeLeaf();
    testReturnStruct3BytesInt2ByteAlignedNativeLeaf();
    testReturnStruct4BytesHomogeneousInt16NativeLeaf();
    testReturnStruct7BytesHomogeneousUint8NativeLeaf();
    testReturnStruct7BytesInt4ByteAlignedNativeLeaf();
    testReturnStruct8BytesIntNativeLeaf();
    testReturnStruct8BytesHomogeneousFloatNativeLeaf();
    testReturnStruct8BytesMixedNativeLeaf();
    testReturnStruct9BytesHomogeneousUint8NativeLeaf();
    testReturnStruct9BytesInt4Or8ByteAlignedNativeLeaf();
    testReturnStruct12BytesHomogeneousFloatNativeLeaf();
    testReturnStruct16BytesHomogeneousFloatNativeLeaf();
    testReturnStruct16BytesMixedNativeLeaf();
    testReturnStruct16BytesMixed2NativeLeaf();
    testReturnStruct17BytesIntNativeLeaf();
    testReturnStruct19BytesHomogeneousUint8NativeLeaf();
    testReturnStruct20BytesHomogeneousInt32NativeLeaf();
    testReturnStruct20BytesHomogeneousFloatNativeLeaf();
    testReturnStruct32BytesHomogeneousDoubleNativeLeaf();
    testReturnStruct40BytesHomogeneousDoubleNativeLeaf();
    testReturnStruct1024BytesHomogeneousUint64NativeLeaf();
    testReturnStruct3BytesPackedIntNativeLeaf();
    testReturnStruct8BytesPackedIntNativeLeaf();
    testReturnStruct9BytesPackedMixedNativeLeaf();
    testReturnUnion4BytesMixedNativeLeaf();
    testReturnUnion8BytesNestedFloatNativeLeaf();
    testReturnUnion9BytesNestedIntNativeLeaf();
    testReturnUnion16BytesNestedFloatNativeLeaf();
  }
}

@Native<Struct1ByteInt Function(Int8)>(
    symbol: 'ReturnStruct1ByteInt', isLeaf: true)
external Struct1ByteInt returnStruct1ByteIntNativeLeaf(int a0);

/// Smallest struct with data.
void testReturnStruct1ByteIntNativeLeaf() {
  int a0;

  a0 = -1;

  final result = returnStruct1ByteIntNativeLeaf(a0);

  print("result = $result");

  Expect.equals(a0, result.a0);
}

@Native<Struct3BytesHomogeneousUint8 Function(Uint8, Uint8, Uint8)>(
    symbol: 'ReturnStruct3BytesHomogeneousUint8', isLeaf: true)
external Struct3BytesHomogeneousUint8
    returnStruct3BytesHomogeneousUint8NativeLeaf(int a0, int a1, int a2);

/// Smaller than word size return value on all architectures.
void testReturnStruct3BytesHomogeneousUint8NativeLeaf() {
  int a0;
  int a1;
  int a2;

  a0 = 1;
  a1 = 2;
  a2 = 3;

  final result = returnStruct3BytesHomogeneousUint8NativeLeaf(a0, a1, a2);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
}

@Native<Struct3BytesInt2ByteAligned Function(Int16, Int8)>(
    symbol: 'ReturnStruct3BytesInt2ByteAligned', isLeaf: true)
external Struct3BytesInt2ByteAligned
    returnStruct3BytesInt2ByteAlignedNativeLeaf(int a0, int a1);

/// Smaller than word size return value on all architectures.
/// With alignment rules taken into account size is 4 bytes.
void testReturnStruct3BytesInt2ByteAlignedNativeLeaf() {
  int a0;
  int a1;

  a0 = -1;
  a1 = 2;

  final result = returnStruct3BytesInt2ByteAlignedNativeLeaf(a0, a1);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
}

@Native<Struct4BytesHomogeneousInt16 Function(Int16, Int16)>(
    symbol: 'ReturnStruct4BytesHomogeneousInt16', isLeaf: true)
external Struct4BytesHomogeneousInt16
    returnStruct4BytesHomogeneousInt16NativeLeaf(int a0, int a1);

/// Word size return value on 32 bit architectures..
void testReturnStruct4BytesHomogeneousInt16NativeLeaf() {
  int a0;
  int a1;

  a0 = -1;
  a1 = 2;

  final result = returnStruct4BytesHomogeneousInt16NativeLeaf(a0, a1);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
}

@Native<
    Struct7BytesHomogeneousUint8 Function(
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8)>(symbol: 'ReturnStruct7BytesHomogeneousUint8', isLeaf: true)
external Struct7BytesHomogeneousUint8
    returnStruct7BytesHomogeneousUint8NativeLeaf(
        int a0, int a1, int a2, int a3, int a4, int a5, int a6);

/// Non-wordsize return value.
void testReturnStruct7BytesHomogeneousUint8NativeLeaf() {
  int a0;
  int a1;
  int a2;
  int a3;
  int a4;
  int a5;
  int a6;

  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;

  final result =
      returnStruct7BytesHomogeneousUint8NativeLeaf(a0, a1, a2, a3, a4, a5, a6);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
  Expect.equals(a3, result.a3);
  Expect.equals(a4, result.a4);
  Expect.equals(a5, result.a5);
  Expect.equals(a6, result.a6);
}

@Native<Struct7BytesInt4ByteAligned Function(Int32, Int16, Int8)>(
    symbol: 'ReturnStruct7BytesInt4ByteAligned', isLeaf: true)
external Struct7BytesInt4ByteAligned
    returnStruct7BytesInt4ByteAlignedNativeLeaf(int a0, int a1, int a2);

/// Non-wordsize return value.
/// With alignment rules taken into account size is 8 bytes.
void testReturnStruct7BytesInt4ByteAlignedNativeLeaf() {
  int a0;
  int a1;
  int a2;

  a0 = -1;
  a1 = 2;
  a2 = -3;

  final result = returnStruct7BytesInt4ByteAlignedNativeLeaf(a0, a1, a2);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
}

@Native<Struct8BytesInt Function(Int16, Int16, Int32)>(
    symbol: 'ReturnStruct8BytesInt', isLeaf: true)
external Struct8BytesInt returnStruct8BytesIntNativeLeaf(
    int a0, int a1, int a2);

/// Return value in integer registers on many architectures.
void testReturnStruct8BytesIntNativeLeaf() {
  int a0;
  int a1;
  int a2;

  a0 = -1;
  a1 = 2;
  a2 = -3;

  final result = returnStruct8BytesIntNativeLeaf(a0, a1, a2);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
}

@Native<Struct8BytesHomogeneousFloat Function(Float, Float)>(
    symbol: 'ReturnStruct8BytesHomogeneousFloat', isLeaf: true)
external Struct8BytesHomogeneousFloat
    returnStruct8BytesHomogeneousFloatNativeLeaf(double a0, double a1);

/// Return value in FP registers on many architectures.
void testReturnStruct8BytesHomogeneousFloatNativeLeaf() {
  double a0;
  double a1;

  a0 = -1.0;
  a1 = 2.0;

  final result = returnStruct8BytesHomogeneousFloatNativeLeaf(a0, a1);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
}

@Native<Struct8BytesMixed Function(Float, Int16, Int16)>(
    symbol: 'ReturnStruct8BytesMixed', isLeaf: true)
external Struct8BytesMixed returnStruct8BytesMixedNativeLeaf(
    double a0, int a1, int a2);

/// Return value split over FP and integer register in x64.
void testReturnStruct8BytesMixedNativeLeaf() {
  double a0;
  int a1;
  int a2;

  a0 = -1.0;
  a1 = 2;
  a2 = -3;

  final result = returnStruct8BytesMixedNativeLeaf(a0, a1, a2);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
}

@Native<
    Struct9BytesHomogeneousUint8 Function(
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8)>(symbol: 'ReturnStruct9BytesHomogeneousUint8', isLeaf: true)
external Struct9BytesHomogeneousUint8
    returnStruct9BytesHomogeneousUint8NativeLeaf(
        int a0, int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8);

/// The minimum alignment of this struct is only 1 byte based on its fields.
/// Test that the memory backing these structs is the right size and that
/// dart:ffi trampolines do not write outside this size.
void testReturnStruct9BytesHomogeneousUint8NativeLeaf() {
  int a0;
  int a1;
  int a2;
  int a3;
  int a4;
  int a5;
  int a6;
  int a7;
  int a8;

  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;

  final result = returnStruct9BytesHomogeneousUint8NativeLeaf(
      a0, a1, a2, a3, a4, a5, a6, a7, a8);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
  Expect.equals(a3, result.a3);
  Expect.equals(a4, result.a4);
  Expect.equals(a5, result.a5);
  Expect.equals(a6, result.a6);
  Expect.equals(a7, result.a7);
  Expect.equals(a8, result.a8);
}

@Native<Struct9BytesInt4Or8ByteAligned Function(Int64, Int8)>(
    symbol: 'ReturnStruct9BytesInt4Or8ByteAligned', isLeaf: true)
external Struct9BytesInt4Or8ByteAligned
    returnStruct9BytesInt4Or8ByteAlignedNativeLeaf(int a0, int a1);

/// Return value in two integer registers on x64.
/// With alignment rules taken into account size is 12 or 16 bytes.
void testReturnStruct9BytesInt4Or8ByteAlignedNativeLeaf() {
  int a0;
  int a1;

  a0 = -1;
  a1 = 2;

  final result = returnStruct9BytesInt4Or8ByteAlignedNativeLeaf(a0, a1);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
}

@Native<Struct12BytesHomogeneousFloat Function(Float, Float, Float)>(
    symbol: 'ReturnStruct12BytesHomogeneousFloat', isLeaf: true)
external Struct12BytesHomogeneousFloat
    returnStruct12BytesHomogeneousFloatNativeLeaf(
        double a0, double a1, double a2);

/// Return value in FPU registers, but does not use all registers on arm hardfp
/// and arm64.
void testReturnStruct12BytesHomogeneousFloatNativeLeaf() {
  double a0;
  double a1;
  double a2;

  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;

  final result = returnStruct12BytesHomogeneousFloatNativeLeaf(a0, a1, a2);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
  Expect.approxEquals(a2, result.a2);
}

@Native<Struct16BytesHomogeneousFloat Function(Float, Float, Float, Float)>(
    symbol: 'ReturnStruct16BytesHomogeneousFloat', isLeaf: true)
external Struct16BytesHomogeneousFloat
    returnStruct16BytesHomogeneousFloatNativeLeaf(
        double a0, double a1, double a2, double a3);

/// Return value in FPU registers on arm hardfp and arm64.
void testReturnStruct16BytesHomogeneousFloatNativeLeaf() {
  double a0;
  double a1;
  double a2;
  double a3;

  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;

  final result = returnStruct16BytesHomogeneousFloatNativeLeaf(a0, a1, a2, a3);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
  Expect.approxEquals(a2, result.a2);
  Expect.approxEquals(a3, result.a3);
}

@Native<Struct16BytesMixed Function(Double, Int64)>(
    symbol: 'ReturnStruct16BytesMixed', isLeaf: true)
external Struct16BytesMixed returnStruct16BytesMixedNativeLeaf(
    double a0, int a1);

/// Return value split over FP and integer register in x64.
void testReturnStruct16BytesMixedNativeLeaf() {
  double a0;
  int a1;

  a0 = -1.0;
  a1 = 2;

  final result = returnStruct16BytesMixedNativeLeaf(a0, a1);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.equals(a1, result.a1);
}

@Native<Struct16BytesMixed2 Function(Float, Float, Float, Int32)>(
    symbol: 'ReturnStruct16BytesMixed2', isLeaf: true)
external Struct16BytesMixed2 returnStruct16BytesMixed2NativeLeaf(
    double a0, double a1, double a2, int a3);

/// Return value split over FP and integer register in x64.
/// The integer register contains half float half int.
void testReturnStruct16BytesMixed2NativeLeaf() {
  double a0;
  double a1;
  double a2;
  int a3;

  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4;

  final result = returnStruct16BytesMixed2NativeLeaf(a0, a1, a2, a3);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
  Expect.approxEquals(a2, result.a2);
  Expect.equals(a3, result.a3);
}

@Native<Struct17BytesInt Function(Int64, Int64, Int8)>(
    symbol: 'ReturnStruct17BytesInt', isLeaf: true)
external Struct17BytesInt returnStruct17BytesIntNativeLeaf(
    int a0, int a1, int a2);

/// Return value returned in preallocated space passed by pointer on most ABIs.
/// Is non word size on purpose, to test that structs are rounded up to word size
/// on all ABIs.
void testReturnStruct17BytesIntNativeLeaf() {
  int a0;
  int a1;
  int a2;

  a0 = -1;
  a1 = 2;
  a2 = -3;

  final result = returnStruct17BytesIntNativeLeaf(a0, a1, a2);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
}

@Native<
    Struct19BytesHomogeneousUint8 Function(
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8,
        Uint8)>(symbol: 'ReturnStruct19BytesHomogeneousUint8', isLeaf: true)
external Struct19BytesHomogeneousUint8
    returnStruct19BytesHomogeneousUint8NativeLeaf(
        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);

/// The minimum alignment of this struct is only 1 byte based on its fields.
/// Test that the memory backing these structs is the right size and that
/// dart:ffi trampolines do not write outside this size.
void testReturnStruct19BytesHomogeneousUint8NativeLeaf() {
  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;

  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
  a9 = 10;
  a10 = 11;
  a11 = 12;
  a12 = 13;
  a13 = 14;
  a14 = 15;
  a15 = 16;
  a16 = 17;
  a17 = 18;
  a18 = 19;

  final result = returnStruct19BytesHomogeneousUint8NativeLeaf(a0, a1, a2, a3,
      a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
  Expect.equals(a3, result.a3);
  Expect.equals(a4, result.a4);
  Expect.equals(a5, result.a5);
  Expect.equals(a6, result.a6);
  Expect.equals(a7, result.a7);
  Expect.equals(a8, result.a8);
  Expect.equals(a9, result.a9);
  Expect.equals(a10, result.a10);
  Expect.equals(a11, result.a11);
  Expect.equals(a12, result.a12);
  Expect.equals(a13, result.a13);
  Expect.equals(a14, result.a14);
  Expect.equals(a15, result.a15);
  Expect.equals(a16, result.a16);
  Expect.equals(a17, result.a17);
  Expect.equals(a18, result.a18);
}

@Native<
    Struct20BytesHomogeneousInt32 Function(Int32, Int32, Int32, Int32,
        Int32)>(symbol: 'ReturnStruct20BytesHomogeneousInt32', isLeaf: true)
external Struct20BytesHomogeneousInt32
    returnStruct20BytesHomogeneousInt32NativeLeaf(
        int a0, int a1, int a2, int a3, int a4);

/// Return value too big to go in cpu registers on arm64.
void testReturnStruct20BytesHomogeneousInt32NativeLeaf() {
  int a0;
  int a1;
  int a2;
  int a3;
  int a4;

  a0 = -1;
  a1 = 2;
  a2 = -3;
  a3 = 4;
  a4 = -5;

  final result =
      returnStruct20BytesHomogeneousInt32NativeLeaf(a0, a1, a2, a3, a4);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
  Expect.equals(a3, result.a3);
  Expect.equals(a4, result.a4);
}

@Native<
    Struct20BytesHomogeneousFloat Function(Float, Float, Float, Float,
        Float)>(symbol: 'ReturnStruct20BytesHomogeneousFloat', isLeaf: true)
external Struct20BytesHomogeneousFloat
    returnStruct20BytesHomogeneousFloatNativeLeaf(
        double a0, double a1, double a2, double a3, double a4);

/// Return value too big to go in FPU registers on x64, arm hardfp and arm64.
void testReturnStruct20BytesHomogeneousFloatNativeLeaf() {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;

  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;

  final result =
      returnStruct20BytesHomogeneousFloatNativeLeaf(a0, a1, a2, a3, a4);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
  Expect.approxEquals(a2, result.a2);
  Expect.approxEquals(a3, result.a3);
  Expect.approxEquals(a4, result.a4);
}

@Native<
    Struct32BytesHomogeneousDouble Function(Double, Double, Double,
        Double)>(symbol: 'ReturnStruct32BytesHomogeneousDouble', isLeaf: true)
external Struct32BytesHomogeneousDouble
    returnStruct32BytesHomogeneousDoubleNativeLeaf(
        double a0, double a1, double a2, double a3);

/// Return value in FPU registers on arm64.
void testReturnStruct32BytesHomogeneousDoubleNativeLeaf() {
  double a0;
  double a1;
  double a2;
  double a3;

  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;

  final result = returnStruct32BytesHomogeneousDoubleNativeLeaf(a0, a1, a2, a3);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
  Expect.approxEquals(a2, result.a2);
  Expect.approxEquals(a3, result.a3);
}

@Native<
    Struct40BytesHomogeneousDouble Function(Double, Double, Double, Double,
        Double)>(symbol: 'ReturnStruct40BytesHomogeneousDouble', isLeaf: true)
external Struct40BytesHomogeneousDouble
    returnStruct40BytesHomogeneousDoubleNativeLeaf(
        double a0, double a1, double a2, double a3, double a4);

/// Return value too big to go in FPU registers on arm64.
void testReturnStruct40BytesHomogeneousDoubleNativeLeaf() {
  double a0;
  double a1;
  double a2;
  double a3;
  double a4;

  a0 = -1.0;
  a1 = 2.0;
  a2 = -3.0;
  a3 = 4.0;
  a4 = -5.0;

  final result =
      returnStruct40BytesHomogeneousDoubleNativeLeaf(a0, a1, a2, a3, a4);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
  Expect.approxEquals(a2, result.a2);
  Expect.approxEquals(a3, result.a3);
  Expect.approxEquals(a4, result.a4);
}

@Native<
    Struct1024BytesHomogeneousUint64 Function(
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64,
        Uint64)>(symbol: 'ReturnStruct1024BytesHomogeneousUint64', isLeaf: true)
external Struct1024BytesHomogeneousUint64
    returnStruct1024BytesHomogeneousUint64NativeLeaf(
        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,
        int a20,
        int a21,
        int a22,
        int a23,
        int a24,
        int a25,
        int a26,
        int a27,
        int a28,
        int a29,
        int a30,
        int a31,
        int a32,
        int a33,
        int a34,
        int a35,
        int a36,
        int a37,
        int a38,
        int a39,
        int a40,
        int a41,
        int a42,
        int a43,
        int a44,
        int a45,
        int a46,
        int a47,
        int a48,
        int a49,
        int a50,
        int a51,
        int a52,
        int a53,
        int a54,
        int a55,
        int a56,
        int a57,
        int a58,
        int a59,
        int a60,
        int a61,
        int a62,
        int a63,
        int a64,
        int a65,
        int a66,
        int a67,
        int a68,
        int a69,
        int a70,
        int a71,
        int a72,
        int a73,
        int a74,
        int a75,
        int a76,
        int a77,
        int a78,
        int a79,
        int a80,
        int a81,
        int a82,
        int a83,
        int a84,
        int a85,
        int a86,
        int a87,
        int a88,
        int a89,
        int a90,
        int a91,
        int a92,
        int a93,
        int a94,
        int a95,
        int a96,
        int a97,
        int a98,
        int a99,
        int a100,
        int a101,
        int a102,
        int a103,
        int a104,
        int a105,
        int a106,
        int a107,
        int a108,
        int a109,
        int a110,
        int a111,
        int a112,
        int a113,
        int a114,
        int a115,
        int a116,
        int a117,
        int a118,
        int a119,
        int a120,
        int a121,
        int a122,
        int a123,
        int a124,
        int a125,
        int a126,
        int a127);

/// Test 1kb struct.
void testReturnStruct1024BytesHomogeneousUint64NativeLeaf() {
  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;
  int a20;
  int a21;
  int a22;
  int a23;
  int a24;
  int a25;
  int a26;
  int a27;
  int a28;
  int a29;
  int a30;
  int a31;
  int a32;
  int a33;
  int a34;
  int a35;
  int a36;
  int a37;
  int a38;
  int a39;
  int a40;
  int a41;
  int a42;
  int a43;
  int a44;
  int a45;
  int a46;
  int a47;
  int a48;
  int a49;
  int a50;
  int a51;
  int a52;
  int a53;
  int a54;
  int a55;
  int a56;
  int a57;
  int a58;
  int a59;
  int a60;
  int a61;
  int a62;
  int a63;
  int a64;
  int a65;
  int a66;
  int a67;
  int a68;
  int a69;
  int a70;
  int a71;
  int a72;
  int a73;
  int a74;
  int a75;
  int a76;
  int a77;
  int a78;
  int a79;
  int a80;
  int a81;
  int a82;
  int a83;
  int a84;
  int a85;
  int a86;
  int a87;
  int a88;
  int a89;
  int a90;
  int a91;
  int a92;
  int a93;
  int a94;
  int a95;
  int a96;
  int a97;
  int a98;
  int a99;
  int a100;
  int a101;
  int a102;
  int a103;
  int a104;
  int a105;
  int a106;
  int a107;
  int a108;
  int a109;
  int a110;
  int a111;
  int a112;
  int a113;
  int a114;
  int a115;
  int a116;
  int a117;
  int a118;
  int a119;
  int a120;
  int a121;
  int a122;
  int a123;
  int a124;
  int a125;
  int a126;
  int a127;

  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;
  a5 = 6;
  a6 = 7;
  a7 = 8;
  a8 = 9;
  a9 = 10;
  a10 = 11;
  a11 = 12;
  a12 = 13;
  a13 = 14;
  a14 = 15;
  a15 = 16;
  a16 = 17;
  a17 = 18;
  a18 = 19;
  a19 = 20;
  a20 = 21;
  a21 = 22;
  a22 = 23;
  a23 = 24;
  a24 = 25;
  a25 = 26;
  a26 = 27;
  a27 = 28;
  a28 = 29;
  a29 = 30;
  a30 = 31;
  a31 = 32;
  a32 = 33;
  a33 = 34;
  a34 = 35;
  a35 = 36;
  a36 = 37;
  a37 = 38;
  a38 = 39;
  a39 = 40;
  a40 = 41;
  a41 = 42;
  a42 = 43;
  a43 = 44;
  a44 = 45;
  a45 = 46;
  a46 = 47;
  a47 = 48;
  a48 = 49;
  a49 = 50;
  a50 = 51;
  a51 = 52;
  a52 = 53;
  a53 = 54;
  a54 = 55;
  a55 = 56;
  a56 = 57;
  a57 = 58;
  a58 = 59;
  a59 = 60;
  a60 = 61;
  a61 = 62;
  a62 = 63;
  a63 = 64;
  a64 = 65;
  a65 = 66;
  a66 = 67;
  a67 = 68;
  a68 = 69;
  a69 = 70;
  a70 = 71;
  a71 = 72;
  a72 = 73;
  a73 = 74;
  a74 = 75;
  a75 = 76;
  a76 = 77;
  a77 = 78;
  a78 = 79;
  a79 = 80;
  a80 = 81;
  a81 = 82;
  a82 = 83;
  a83 = 84;
  a84 = 85;
  a85 = 86;
  a86 = 87;
  a87 = 88;
  a88 = 89;
  a89 = 90;
  a90 = 91;
  a91 = 92;
  a92 = 93;
  a93 = 94;
  a94 = 95;
  a95 = 96;
  a96 = 97;
  a97 = 98;
  a98 = 99;
  a99 = 100;
  a100 = 101;
  a101 = 102;
  a102 = 103;
  a103 = 104;
  a104 = 105;
  a105 = 106;
  a106 = 107;
  a107 = 108;
  a108 = 109;
  a109 = 110;
  a110 = 111;
  a111 = 112;
  a112 = 113;
  a113 = 114;
  a114 = 115;
  a115 = 116;
  a116 = 117;
  a117 = 118;
  a118 = 119;
  a119 = 120;
  a120 = 121;
  a121 = 122;
  a122 = 123;
  a123 = 124;
  a124 = 125;
  a125 = 126;
  a126 = 127;
  a127 = 128;

  final result = returnStruct1024BytesHomogeneousUint64NativeLeaf(
      a0,
      a1,
      a2,
      a3,
      a4,
      a5,
      a6,
      a7,
      a8,
      a9,
      a10,
      a11,
      a12,
      a13,
      a14,
      a15,
      a16,
      a17,
      a18,
      a19,
      a20,
      a21,
      a22,
      a23,
      a24,
      a25,
      a26,
      a27,
      a28,
      a29,
      a30,
      a31,
      a32,
      a33,
      a34,
      a35,
      a36,
      a37,
      a38,
      a39,
      a40,
      a41,
      a42,
      a43,
      a44,
      a45,
      a46,
      a47,
      a48,
      a49,
      a50,
      a51,
      a52,
      a53,
      a54,
      a55,
      a56,
      a57,
      a58,
      a59,
      a60,
      a61,
      a62,
      a63,
      a64,
      a65,
      a66,
      a67,
      a68,
      a69,
      a70,
      a71,
      a72,
      a73,
      a74,
      a75,
      a76,
      a77,
      a78,
      a79,
      a80,
      a81,
      a82,
      a83,
      a84,
      a85,
      a86,
      a87,
      a88,
      a89,
      a90,
      a91,
      a92,
      a93,
      a94,
      a95,
      a96,
      a97,
      a98,
      a99,
      a100,
      a101,
      a102,
      a103,
      a104,
      a105,
      a106,
      a107,
      a108,
      a109,
      a110,
      a111,
      a112,
      a113,
      a114,
      a115,
      a116,
      a117,
      a118,
      a119,
      a120,
      a121,
      a122,
      a123,
      a124,
      a125,
      a126,
      a127);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
  Expect.equals(a3, result.a3);
  Expect.equals(a4, result.a4);
  Expect.equals(a5, result.a5);
  Expect.equals(a6, result.a6);
  Expect.equals(a7, result.a7);
  Expect.equals(a8, result.a8);
  Expect.equals(a9, result.a9);
  Expect.equals(a10, result.a10);
  Expect.equals(a11, result.a11);
  Expect.equals(a12, result.a12);
  Expect.equals(a13, result.a13);
  Expect.equals(a14, result.a14);
  Expect.equals(a15, result.a15);
  Expect.equals(a16, result.a16);
  Expect.equals(a17, result.a17);
  Expect.equals(a18, result.a18);
  Expect.equals(a19, result.a19);
  Expect.equals(a20, result.a20);
  Expect.equals(a21, result.a21);
  Expect.equals(a22, result.a22);
  Expect.equals(a23, result.a23);
  Expect.equals(a24, result.a24);
  Expect.equals(a25, result.a25);
  Expect.equals(a26, result.a26);
  Expect.equals(a27, result.a27);
  Expect.equals(a28, result.a28);
  Expect.equals(a29, result.a29);
  Expect.equals(a30, result.a30);
  Expect.equals(a31, result.a31);
  Expect.equals(a32, result.a32);
  Expect.equals(a33, result.a33);
  Expect.equals(a34, result.a34);
  Expect.equals(a35, result.a35);
  Expect.equals(a36, result.a36);
  Expect.equals(a37, result.a37);
  Expect.equals(a38, result.a38);
  Expect.equals(a39, result.a39);
  Expect.equals(a40, result.a40);
  Expect.equals(a41, result.a41);
  Expect.equals(a42, result.a42);
  Expect.equals(a43, result.a43);
  Expect.equals(a44, result.a44);
  Expect.equals(a45, result.a45);
  Expect.equals(a46, result.a46);
  Expect.equals(a47, result.a47);
  Expect.equals(a48, result.a48);
  Expect.equals(a49, result.a49);
  Expect.equals(a50, result.a50);
  Expect.equals(a51, result.a51);
  Expect.equals(a52, result.a52);
  Expect.equals(a53, result.a53);
  Expect.equals(a54, result.a54);
  Expect.equals(a55, result.a55);
  Expect.equals(a56, result.a56);
  Expect.equals(a57, result.a57);
  Expect.equals(a58, result.a58);
  Expect.equals(a59, result.a59);
  Expect.equals(a60, result.a60);
  Expect.equals(a61, result.a61);
  Expect.equals(a62, result.a62);
  Expect.equals(a63, result.a63);
  Expect.equals(a64, result.a64);
  Expect.equals(a65, result.a65);
  Expect.equals(a66, result.a66);
  Expect.equals(a67, result.a67);
  Expect.equals(a68, result.a68);
  Expect.equals(a69, result.a69);
  Expect.equals(a70, result.a70);
  Expect.equals(a71, result.a71);
  Expect.equals(a72, result.a72);
  Expect.equals(a73, result.a73);
  Expect.equals(a74, result.a74);
  Expect.equals(a75, result.a75);
  Expect.equals(a76, result.a76);
  Expect.equals(a77, result.a77);
  Expect.equals(a78, result.a78);
  Expect.equals(a79, result.a79);
  Expect.equals(a80, result.a80);
  Expect.equals(a81, result.a81);
  Expect.equals(a82, result.a82);
  Expect.equals(a83, result.a83);
  Expect.equals(a84, result.a84);
  Expect.equals(a85, result.a85);
  Expect.equals(a86, result.a86);
  Expect.equals(a87, result.a87);
  Expect.equals(a88, result.a88);
  Expect.equals(a89, result.a89);
  Expect.equals(a90, result.a90);
  Expect.equals(a91, result.a91);
  Expect.equals(a92, result.a92);
  Expect.equals(a93, result.a93);
  Expect.equals(a94, result.a94);
  Expect.equals(a95, result.a95);
  Expect.equals(a96, result.a96);
  Expect.equals(a97, result.a97);
  Expect.equals(a98, result.a98);
  Expect.equals(a99, result.a99);
  Expect.equals(a100, result.a100);
  Expect.equals(a101, result.a101);
  Expect.equals(a102, result.a102);
  Expect.equals(a103, result.a103);
  Expect.equals(a104, result.a104);
  Expect.equals(a105, result.a105);
  Expect.equals(a106, result.a106);
  Expect.equals(a107, result.a107);
  Expect.equals(a108, result.a108);
  Expect.equals(a109, result.a109);
  Expect.equals(a110, result.a110);
  Expect.equals(a111, result.a111);
  Expect.equals(a112, result.a112);
  Expect.equals(a113, result.a113);
  Expect.equals(a114, result.a114);
  Expect.equals(a115, result.a115);
  Expect.equals(a116, result.a116);
  Expect.equals(a117, result.a117);
  Expect.equals(a118, result.a118);
  Expect.equals(a119, result.a119);
  Expect.equals(a120, result.a120);
  Expect.equals(a121, result.a121);
  Expect.equals(a122, result.a122);
  Expect.equals(a123, result.a123);
  Expect.equals(a124, result.a124);
  Expect.equals(a125, result.a125);
  Expect.equals(a126, result.a126);
  Expect.equals(a127, result.a127);
}

@Native<Struct3BytesPackedInt Function(Int8, Int16)>(
    symbol: 'ReturnStruct3BytesPackedInt', isLeaf: true)
external Struct3BytesPackedInt returnStruct3BytesPackedIntNativeLeaf(
    int a0, int a1);

/// Small struct with mis-aligned member.
void testReturnStruct3BytesPackedIntNativeLeaf() {
  int a0;
  int a1;

  a0 = -1;
  a1 = 2;

  final result = returnStruct3BytesPackedIntNativeLeaf(a0, a1);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
}

@Native<Struct8BytesPackedInt Function(Uint8, Uint32, Uint8, Uint8, Uint8)>(
    symbol: 'ReturnStruct8BytesPackedInt', isLeaf: true)
external Struct8BytesPackedInt returnStruct8BytesPackedIntNativeLeaf(
    int a0, int a1, int a2, int a3, int a4);

/// Struct with mis-aligned member.
void testReturnStruct8BytesPackedIntNativeLeaf() {
  int a0;
  int a1;
  int a2;
  int a3;
  int a4;

  a0 = 1;
  a1 = 2;
  a2 = 3;
  a3 = 4;
  a4 = 5;

  final result = returnStruct8BytesPackedIntNativeLeaf(a0, a1, a2, a3, a4);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.equals(a1, result.a1);
  Expect.equals(a2, result.a2);
  Expect.equals(a3, result.a3);
  Expect.equals(a4, result.a4);
}

@Native<Struct9BytesPackedMixed Function(Uint8, Double)>(
    symbol: 'ReturnStruct9BytesPackedMixed', isLeaf: true)
external Struct9BytesPackedMixed returnStruct9BytesPackedMixedNativeLeaf(
    int a0, double a1);

/// Struct with mis-aligned member.
/// Tests backfilling of CPU and FPU registers.
void testReturnStruct9BytesPackedMixedNativeLeaf() {
  int a0;
  double a1;

  a0 = 1;
  a1 = 2.0;

  final result = returnStruct9BytesPackedMixedNativeLeaf(a0, a1);

  print("result = $result");

  Expect.equals(a0, result.a0);
  Expect.approxEquals(a1, result.a1);
}

@Native<Union4BytesMixed Function(Uint32)>(
    symbol: 'ReturnUnion4BytesMixed', isLeaf: true)
external Union4BytesMixed returnUnion4BytesMixedNativeLeaf(int a0);

/// Returning a mixed integer/float union.
void testReturnUnion4BytesMixedNativeLeaf() {
  int a0;

  a0 = 1;

  final result = returnUnion4BytesMixedNativeLeaf(a0);

  print("result = $result");

  Expect.equals(a0, result.a0);
}

@Native<Union8BytesNestedFloat Function(Double)>(
    symbol: 'ReturnUnion8BytesNestedFloat', isLeaf: true)
external Union8BytesNestedFloat returnUnion8BytesNestedFloatNativeLeaf(
    double a0);

/// Returning a floating point only union.
void testReturnUnion8BytesNestedFloatNativeLeaf() {
  double a0;

  a0 = -1.0;

  final result = returnUnion8BytesNestedFloatNativeLeaf(a0);

  print("result = $result");

  Expect.approxEquals(a0, result.a0);
}

@Native<Union9BytesNestedInt Function(Struct8BytesInt)>(
    symbol: 'ReturnUnion9BytesNestedInt', isLeaf: true)
external Union9BytesNestedInt returnUnion9BytesNestedIntNativeLeaf(
    Struct8BytesInt a0);

/// Returning a mixed-size union.
void testReturnUnion9BytesNestedIntNativeLeaf() {
  final a0Pointer = calloc<Struct8BytesInt>();
  final Struct8BytesInt a0 = a0Pointer.ref;

  a0.a0 = -1;
  a0.a1 = 2;
  a0.a2 = -3;

  final result = returnUnion9BytesNestedIntNativeLeaf(a0);

  print("result = $result");

  Expect.equals(a0.a0, result.a0.a0);
  Expect.equals(a0.a1, result.a0.a1);
  Expect.equals(a0.a2, result.a0.a2);

  calloc.free(a0Pointer);
}

@Native<Union16BytesNestedFloat Function(Struct8BytesHomogeneousFloat)>(
    symbol: 'ReturnUnion16BytesNestedFloat', isLeaf: true)
external Union16BytesNestedFloat returnUnion16BytesNestedFloatNativeLeaf(
    Struct8BytesHomogeneousFloat a0);

/// Returning union with homogenous floats.
void testReturnUnion16BytesNestedFloatNativeLeaf() {
  final a0Pointer = calloc<Struct8BytesHomogeneousFloat>();
  final Struct8BytesHomogeneousFloat a0 = a0Pointer.ref;

  a0.a0 = -1.0;
  a0.a1 = 2.0;

  final result = returnUnion16BytesNestedFloatNativeLeaf(a0);

  print("result = $result");

  Expect.approxEquals(a0.a0, result.a0.a0);
  Expect.approxEquals(a0.a1, result.a0.a1);

  calloc.free(a0Pointer);
}