<?php

declare(strict_types=1);

namespace Nsfisis\Waddiwasi\Tests\SpecTestsuites\Core;

use Nsfisis\Waddiwasi\Tests\SpecTestsuites\SpecTestsuiteBase;
use PHPUnit\Framework\Attributes\DoesNotPerformAssertions;

final class AlignTest extends SpecTestsuiteBase
{
    public function testModule0(): void
    {
        $this->runModuleCommand(
            filename: 'align.0.wasm',
            name: null,
            line: 3,
        );
    }

    public function testModule1(): void
    {
        $this->runModuleCommand(
            filename: 'align.1.wasm',
            name: null,
            line: 4,
        );
    }

    public function testModule2(): void
    {
        $this->runModuleCommand(
            filename: 'align.2.wasm',
            name: null,
            line: 5,
        );
    }

    public function testModule3(): void
    {
        $this->runModuleCommand(
            filename: 'align.3.wasm',
            name: null,
            line: 6,
        );
    }

    public function testModule4(): void
    {
        $this->runModuleCommand(
            filename: 'align.4.wasm',
            name: null,
            line: 7,
        );
    }

    public function testModule5(): void
    {
        $this->runModuleCommand(
            filename: 'align.5.wasm',
            name: null,
            line: 8,
        );
    }

    public function testModule6(): void
    {
        $this->runModuleCommand(
            filename: 'align.6.wasm',
            name: null,
            line: 9,
        );
    }

    public function testModule7(): void
    {
        $this->runModuleCommand(
            filename: 'align.7.wasm',
            name: null,
            line: 10,
        );
    }

    public function testModule8(): void
    {
        $this->runModuleCommand(
            filename: 'align.8.wasm',
            name: null,
            line: 11,
        );
    }

    public function testModule9(): void
    {
        $this->runModuleCommand(
            filename: 'align.9.wasm',
            name: null,
            line: 12,
        );
    }

    public function testModule10(): void
    {
        $this->runModuleCommand(
            filename: 'align.10.wasm',
            name: null,
            line: 13,
        );
    }

    public function testModule11(): void
    {
        $this->runModuleCommand(
            filename: 'align.11.wasm',
            name: null,
            line: 14,
        );
    }

    public function testModule12(): void
    {
        $this->runModuleCommand(
            filename: 'align.12.wasm',
            name: null,
            line: 15,
        );
    }

    public function testModule13(): void
    {
        $this->runModuleCommand(
            filename: 'align.13.wasm',
            name: null,
            line: 16,
        );
    }

    public function testModule14(): void
    {
        $this->runModuleCommand(
            filename: 'align.14.wasm',
            name: null,
            line: 17,
        );
    }

    public function testModule15(): void
    {
        $this->runModuleCommand(
            filename: 'align.15.wasm',
            name: null,
            line: 18,
        );
    }

    public function testModule16(): void
    {
        $this->runModuleCommand(
            filename: 'align.16.wasm',
            name: null,
            line: 19,
        );
    }

    public function testModule17(): void
    {
        $this->runModuleCommand(
            filename: 'align.17.wasm',
            name: null,
            line: 20,
        );
    }

    public function testModule18(): void
    {
        $this->runModuleCommand(
            filename: 'align.18.wasm',
            name: null,
            line: 21,
        );
    }

    public function testModule19(): void
    {
        $this->runModuleCommand(
            filename: 'align.19.wasm',
            name: null,
            line: 22,
        );
    }

    public function testModule20(): void
    {
        $this->runModuleCommand(
            filename: 'align.20.wasm',
            name: null,
            line: 23,
        );
    }

    public function testModule21(): void
    {
        $this->runModuleCommand(
            filename: 'align.21.wasm',
            name: null,
            line: 24,
        );
    }

    public function testModule22(): void
    {
        $this->runModuleCommand(
            filename: 'align.22.wasm',
            name: null,
            line: 25,
        );
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed23(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed24(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed25(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed26(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed27(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed28(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed29(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed30(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed31(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed32(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed33(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed34(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed35(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed36(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed37(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed38(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed39(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed40(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed41(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed42(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed43(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed44(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed45(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed46(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed47(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed48(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed49(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed50(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed51(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed52(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed53(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed54(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed55(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed56(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed57(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed58(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed59(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed60(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed61(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed62(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed63(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed64(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed65(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed66(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed67(): void
    {
    }

    #[DoesNotPerformAssertions]
    public function testAssertMalformed68(): void
    {
    }

    public function testAssertInvalid69(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.69.wasm',
            text: 'alignment must not be larger than natural',
            line: 306,
        );
    }

    public function testAssertInvalid70(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.70.wasm',
            text: 'alignment must not be larger than natural',
            line: 310,
        );
    }

    public function testAssertInvalid71(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.71.wasm',
            text: 'alignment must not be larger than natural',
            line: 314,
        );
    }

    public function testAssertInvalid72(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.72.wasm',
            text: 'alignment must not be larger than natural',
            line: 318,
        );
    }

    public function testAssertInvalid73(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.73.wasm',
            text: 'alignment must not be larger than natural',
            line: 322,
        );
    }

    public function testAssertInvalid74(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.74.wasm',
            text: 'alignment must not be larger than natural',
            line: 326,
        );
    }

    public function testAssertInvalid75(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.75.wasm',
            text: 'alignment must not be larger than natural',
            line: 330,
        );
    }

    public function testAssertInvalid76(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.76.wasm',
            text: 'alignment must not be larger than natural',
            line: 334,
        );
    }

    public function testAssertInvalid77(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.77.wasm',
            text: 'alignment must not be larger than natural',
            line: 338,
        );
    }

    public function testAssertInvalid78(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.78.wasm',
            text: 'alignment must not be larger than natural',
            line: 342,
        );
    }

    public function testAssertInvalid79(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.79.wasm',
            text: 'alignment must not be larger than natural',
            line: 346,
        );
    }

    public function testAssertInvalid80(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.80.wasm',
            text: 'alignment must not be larger than natural',
            line: 350,
        );
    }

    public function testAssertInvalid81(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.81.wasm',
            text: 'alignment must not be larger than natural',
            line: 354,
        );
    }

    public function testAssertInvalid82(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.82.wasm',
            text: 'alignment must not be larger than natural',
            line: 358,
        );
    }

    public function testAssertInvalid83(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.83.wasm',
            text: 'alignment must not be larger than natural',
            line: 363,
        );
    }

    public function testAssertInvalid84(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.84.wasm',
            text: 'alignment must not be larger than natural',
            line: 367,
        );
    }

    public function testAssertInvalid85(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.85.wasm',
            text: 'alignment must not be larger than natural',
            line: 371,
        );
    }

    public function testAssertInvalid86(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.86.wasm',
            text: 'alignment must not be larger than natural',
            line: 375,
        );
    }

    public function testAssertInvalid87(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.87.wasm',
            text: 'alignment must not be larger than natural',
            line: 379,
        );
    }

    public function testAssertInvalid88(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.88.wasm',
            text: 'alignment must not be larger than natural',
            line: 383,
        );
    }

    public function testAssertInvalid89(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.89.wasm',
            text: 'alignment must not be larger than natural',
            line: 387,
        );
    }

    public function testAssertInvalid90(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.90.wasm',
            text: 'alignment must not be larger than natural',
            line: 391,
        );
    }

    public function testAssertInvalid91(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.91.wasm',
            text: 'alignment must not be larger than natural',
            line: 395,
        );
    }

    public function testAssertInvalid92(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.92.wasm',
            text: 'alignment must not be larger than natural',
            line: 399,
        );
    }

    public function testAssertInvalid93(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.93.wasm',
            text: 'alignment must not be larger than natural',
            line: 403,
        );
    }

    public function testAssertInvalid94(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.94.wasm',
            text: 'alignment must not be larger than natural',
            line: 407,
        );
    }

    public function testAssertInvalid95(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.95.wasm',
            text: 'alignment must not be larger than natural',
            line: 411,
        );
    }

    public function testAssertInvalid96(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.96.wasm',
            text: 'alignment must not be larger than natural',
            line: 415,
        );
    }

    public function testAssertInvalid97(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.97.wasm',
            text: 'alignment must not be larger than natural',
            line: 420,
        );
    }

    public function testAssertInvalid98(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.98.wasm',
            text: 'alignment must not be larger than natural',
            line: 424,
        );
    }

    public function testAssertInvalid99(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.99.wasm',
            text: 'alignment must not be larger than natural',
            line: 428,
        );
    }

    public function testAssertInvalid100(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.100.wasm',
            text: 'alignment must not be larger than natural',
            line: 432,
        );
    }

    public function testAssertInvalid101(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.101.wasm',
            text: 'alignment must not be larger than natural',
            line: 436,
        );
    }

    public function testAssertInvalid102(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.102.wasm',
            text: 'alignment must not be larger than natural',
            line: 440,
        );
    }

    public function testAssertInvalid103(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.103.wasm',
            text: 'alignment must not be larger than natural',
            line: 444,
        );
    }

    public function testAssertInvalid104(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.104.wasm',
            text: 'alignment must not be larger than natural',
            line: 448,
        );
    }

    public function testAssertInvalid105(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.105.wasm',
            text: 'alignment must not be larger than natural',
            line: 452,
        );
    }

    public function testModule106(): void
    {
        $this->runModuleCommand(
            filename: 'align.106.wasm',
            name: null,
            line: 458,
        );
    }

    public function testAssertReturn107(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f32_align_switch', 'args' => [['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'f32', 'value' => '1092616192']],
            line: 802,
        );
    }

    public function testAssertReturn108(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f32_align_switch', 'args' => [['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'f32', 'value' => '1092616192']],
            line: 803,
        );
    }

    public function testAssertReturn109(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f32_align_switch', 'args' => [['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'f32', 'value' => '1092616192']],
            line: 804,
        );
    }

    public function testAssertReturn110(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f32_align_switch', 'args' => [['type' => 'i32', 'value' => '3']]],
            expected: [['type' => 'f32', 'value' => '1092616192']],
            line: 805,
        );
    }

    public function testAssertReturn111(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f64_align_switch', 'args' => [['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'f64', 'value' => '4621819117588971520']],
            line: 807,
        );
    }

    public function testAssertReturn112(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f64_align_switch', 'args' => [['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'f64', 'value' => '4621819117588971520']],
            line: 808,
        );
    }

    public function testAssertReturn113(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f64_align_switch', 'args' => [['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'f64', 'value' => '4621819117588971520']],
            line: 809,
        );
    }

    public function testAssertReturn114(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f64_align_switch', 'args' => [['type' => 'i32', 'value' => '3']]],
            expected: [['type' => 'f64', 'value' => '4621819117588971520']],
            line: 810,
        );
    }

    public function testAssertReturn115(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'f64_align_switch', 'args' => [['type' => 'i32', 'value' => '4']]],
            expected: [['type' => 'f64', 'value' => '4621819117588971520']],
            line: 811,
        );
    }

    public function testAssertReturn116(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '0'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 813,
        );
    }

    public function testAssertReturn117(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '0'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 814,
        );
    }

    public function testAssertReturn118(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '1'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 815,
        );
    }

    public function testAssertReturn119(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '1'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 816,
        );
    }

    public function testAssertReturn120(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '2'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 817,
        );
    }

    public function testAssertReturn121(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '2'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 818,
        );
    }

    public function testAssertReturn122(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '2'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 819,
        );
    }

    public function testAssertReturn123(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '3'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 820,
        );
    }

    public function testAssertReturn124(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '3'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 821,
        );
    }

    public function testAssertReturn125(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '3'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 822,
        );
    }

    public function testAssertReturn126(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 823,
        );
    }

    public function testAssertReturn127(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 824,
        );
    }

    public function testAssertReturn128(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 825,
        );
    }

    public function testAssertReturn129(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i32_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '4']]],
            expected: [['type' => 'i32', 'value' => '10']],
            line: 826,
        );
    }

    public function testAssertReturn130(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '0'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 828,
        );
    }

    public function testAssertReturn131(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '0'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 829,
        );
    }

    public function testAssertReturn132(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '1'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 830,
        );
    }

    public function testAssertReturn133(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '1'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 831,
        );
    }

    public function testAssertReturn134(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '2'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 832,
        );
    }

    public function testAssertReturn135(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '2'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 833,
        );
    }

    public function testAssertReturn136(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '2'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 834,
        );
    }

    public function testAssertReturn137(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '3'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 835,
        );
    }

    public function testAssertReturn138(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '3'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 836,
        );
    }

    public function testAssertReturn139(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '3'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 837,
        );
    }

    public function testAssertReturn140(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 838,
        );
    }

    public function testAssertReturn141(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 839,
        );
    }

    public function testAssertReturn142(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 840,
        );
    }

    public function testAssertReturn143(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '4'], ['type' => 'i32', 'value' => '4']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 841,
        );
    }

    public function testAssertReturn144(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '5'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 842,
        );
    }

    public function testAssertReturn145(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '5'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 843,
        );
    }

    public function testAssertReturn146(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '5'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 844,
        );
    }

    public function testAssertReturn147(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '5'], ['type' => 'i32', 'value' => '4']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 845,
        );
    }

    public function testAssertReturn148(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '6'], ['type' => 'i32', 'value' => '0']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 846,
        );
    }

    public function testAssertReturn149(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '6'], ['type' => 'i32', 'value' => '1']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 847,
        );
    }

    public function testAssertReturn150(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '6'], ['type' => 'i32', 'value' => '2']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 848,
        );
    }

    public function testAssertReturn151(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '6'], ['type' => 'i32', 'value' => '4']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 849,
        );
    }

    public function testAssertReturn152(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'i64_align_switch', 'args' => [['type' => 'i32', 'value' => '6'], ['type' => 'i32', 'value' => '8']]],
            expected: [['type' => 'i64', 'value' => '10']],
            line: 850,
        );
    }

    public function testModule153(): void
    {
        $this->runModuleCommand(
            filename: 'align.107.wasm',
            name: null,
            line: 854,
        );
    }

    public function testAssertTrap154(): void
    {
        $this->runAssertTrapCommand(
            action: ['type' => 'invoke', 'field' => 'store', 'args' => [['type' => 'i32', 'value' => '65532'], ['type' => 'i64', 'value' => '18446744073709551615']]],
            text: 'out of bounds memory access',
            line: 864,
        );
    }

    public function testAssertReturn155(): void
    {
        $this->runAssertReturnCommand(
            action: ['type' => 'invoke', 'field' => 'load', 'args' => [['type' => 'i32', 'value' => '65532']]],
            expected: [['type' => 'i32', 'value' => '0']],
            line: 866,
        );
    }

    public function testAssertInvalid156(): void
    {
        $this->runAssertInvalidCommand(
            filename: 'align.108.wasm',
            text: 'alignment must not be larger than natural',
            line: 873,
        );
    }

    public function testAssertMalformed157(): void
    {
        $this->runAssertMalformedCommand(
            filename: 'align.109.wasm',
            text: 'malformed memop flags',
            line: 892,
        );
    }

    public function testAssertMalformed158(): void
    {
        $this->runAssertMalformedCommand(
            filename: 'align.110.wasm',
            text: 'malformed memop flags',
            line: 911,
        );
    }

    public function testAssertMalformed159(): void
    {
        $this->runAssertMalformedCommand(
            filename: 'align.111.wasm',
            text: 'malformed memop flags',
            line: 930,
        );
    }

    public function testAssertMalformed160(): void
    {
        $this->runAssertMalformedCommand(
            filename: 'align.112.wasm',
            text: 'malformed memop flags',
            line: 949,
        );
    }

    public function testAssertMalformed161(): void
    {
        $this->runAssertMalformedCommand(
            filename: 'align.113.wasm',
            text: 'malformed memop flags',
            line: 968,
        );
    }
}