// File: cassioneri[P]delayed_init/delayed_init.cpp
// Function: main
int main() {
  
  /***
   * Test default-constructor.
   */

  test_default_constructor(__LINE__);

  /***
   * Create non-const/const helpers.
   */
   
  helper h;
  const helper ch;
  
  /***
   * Test constructor from helper.
   */

  // lvalue.
  test_constructor<helper>(__LINE__, h, true, {helper::copy_constructor});
  test_constructor<const helper>(__LINE__, h, true,
    {helper::copy_constructor});

  // const lvalue.
  test_constructor<helper>(__LINE__, ch, true, {helper::copy_constructor});
  test_constructor<const helper>(__LINE__, ch, true,
    {helper::copy_constructor});

  // rvalue.
  test_constructor<helper>(__LINE__, std::move(h), true,
    {helper::move_constructor});
  test_constructor<const helper>(__LINE__, std::move(h), true,
    {helper::move_constructor});

  // const rvalue.
  test_constructor<helper>(__LINE__, std::move(ch), true,
    {helper::copy_constructor});
  test_constructor<const helper>(__LINE__, std::move(ch), true,
    {helper::copy_constructor});

  /***
   * Create default/non-default initialised delayed_init non-const/const.
   */
   
  delayed_init<helper> d0;
  delayed_init<const helper> cd0;
  delayed_init<helper> d1(helper(1));
  delayed_init<const helper> cd1(helper(1));
    
  /***
   * Test constructor from delayed_init.
   */

  // uninitialised lvalue.
  test_constructor<helper>(__LINE__, d0, false, {});
  test_constructor<const helper>(__LINE__, d0, false, {});
  
  // uninitialised const lvalue.
  test_constructor<helper>(__LINE__, cd0, false, {});
  test_constructor<const helper>(__LINE__, cd0, false, {});
  
  // initialised lvalue.
  test_constructor<helper>(__LINE__, d1, true, {helper::copy_constructor});
  test_constructor<const helper>(__LINE__, d1, true,
    {helper::copy_constructor});

  // initialised const lvalue.
  test_constructor<helper>(__LINE__, cd1, true, {helper::copy_constructor});
  test_constructor<const helper>(__LINE__, cd1, true,
    {helper::copy_constructor});

  // uninitialised rvalue.
  test_constructor<helper>(__LINE__, std::move(d0), false, {});
  test_constructor<const helper>(__LINE__, std::move(d0), false, {});
  
  // uninitialised const rvalue.
  test_constructor<helper>(__LINE__, std::move(cd0), false, {});
  test_constructor<const helper>(__LINE__, std::move(cd0), false, {});
  
  // initialised rvalue.
  test_constructor<helper>(__LINE__, std::move(d1), true,
    {helper::move_constructor});
  test_constructor<const helper>(__LINE__, std::move(d1), true,
    {helper::move_constructor});

  // initialised const rvalue.
  test_constructor<helper>(__LINE__, std::move(cd1), true,
    {helper::copy_constructor});
  test_constructor<const helper>(__LINE__, std::move(cd1), true,
    {helper::copy_constructor});

  /**
   * Test destructor.
   */
   
  // uninitialised.
  test_destructor(__LINE__, d0, {});
  
  // initialised.
  test_destructor(__LINE__, d1, {helper::destructor});

  /***
   * Test assignment from helper.
   */
   
  // lvalue -> uninitialised.
  test_assignment(__LINE__, h, d0, true, {helper::copy_constructor});
  
  // lvalue -> initialised.
  test_assignment(__LINE__, h, d1, true, {helper::copy_assignment});
  
  // const lvalue -> uninitialised.
  test_assignment(__LINE__, ch, d0, true, {helper::copy_constructor});
  
  // const lvalue -> initialised.
  test_assignment(__LINE__, ch, d1, true, {helper::copy_assignment});

  // rvalue -> uninitialised.
  test_assignment(__LINE__, std::move(h), d0, true,
    {helper::move_constructor});
  
  // rvalue -> initialised.
  test_assignment(__LINE__, std::move(h), d1, true,
    {helper::move_assignment});

  // const rvalue -> uninitialised.
  test_assignment(__LINE__, std::move(ch), d0, true,
    {helper::copy_constructor});

  // const rvalue -> initialised.
  test_assignment(__LINE__, std::move(ch), d1, true,
    {helper::copy_assignment});

  /***
   * Test assignment from uninitialised delayed_init.
   */
   
  // lvalue -> uninitialised.
  test_assignment(__LINE__, d0, d0, false, {});
  
  // lvalue -> initialised.
  test_assignment(__LINE__, d0, d1, false, {helper::destructor});
  
  // const lvalue -> uninitialised.
  test_assignment(__LINE__, cd0, d0, false, {});

  // const lvalue -> initialised.
  test_assignment(__LINE__, cd0, d1, false, {helper::destructor});

  // rvalue -> uninitialised.
  test_assignment(__LINE__, std::move(d0), d0, false, {});

  // rvalue -> initialised.
  test_assignment(__LINE__, std::move(d0), d1, false, {helper::destructor});

  // const rvalue -> uninitialised.
  test_assignment(__LINE__, std::move(cd0), d0, false, {});

  // const rvalue -> initialised.
  test_assignment(__LINE__, std::move(cd0), d1, false,
    {helper::destructor});

  /***
   * Test assignment from initialised delayed_init.
   */
   
  // lvalue -> uninitialised.
  test_assignment(__LINE__, d1, d0, true, {helper::copy_constructor});
  
  // lvalue -> initialised.
  test_assignment(__LINE__, d1, d1, true, {helper::copy_assignment});
  
  // const lvalue -> uninitialised.
  test_assignment(__LINE__, cd1, d0, true, {helper::copy_constructor});

  // const lvalue -> initialised.
  test_assignment(__LINE__, cd1, d1, true, {helper::copy_assignment});

  // rvalue -> uninitialised.
  test_assignment(__LINE__, std::move(d1), d0, true,
    {helper::move_constructor});

  // rvalue -> initialised.
  test_assignment(__LINE__, std::move(d1), d1, true,
    {helper::move_assignment});

  // const rvalue -> uninitialised.
  test_assignment(__LINE__, std::move(cd1), d0, true,
    {helper::copy_constructor});

  // const rvalue -> initialised.
  test_assignment(__LINE__, std::move(cd1), d1, true,
    {helper::copy_assignment});
  
  /***
   * Test indirection for uninitialised delayed_init.
   */

  test_indirection_uninitialised<delayed_init<helper>>(__LINE__);
  test_indirection_uninitialised<delayed_init<const helper>>(__LINE__);
  
  /***
   * Test indirection for initialised delayed_init.
   */

  test_indirection_initialised<delayed_init<helper>>(__LINE__,
    {helper::non_const_get});
  test_indirection_initialised<delayed_init<const helper>>(__LINE__,
    {helper::const_get});

  /**
   * Test getter from uninitialised delayed_init.
   */

  // non-const.
  test_getter<delayed_init<helper>>(__LINE__, d0, false, false);

  // const.
  test_getter<const delayed_init<helper>>(__LINE__, d0, true, false);
  test_getter<delayed_init<const helper>>(__LINE__, d0, true, false);
  test_getter<const delayed_init<const helper>>(__LINE__, d0, true, false);

  /**
   * Test getter from initialised delayed_init.
   */

  // non-const.
  test_getter<delayed_init<helper>>(__LINE__, d1, false, true);

  // const.
  test_getter<delayed_init<const helper>>(__LINE__, d1, true, true);
  test_getter<const delayed_init<helper>>(__LINE__, d1, true, true);
  test_getter<const delayed_init<const helper>>(__LINE__, d1, true, true);

  /***
   * Test dereference.
   */
   
  // non-const.
  test_dereference<delayed_init<helper>>(__LINE__, {helper::non_const_get});

  // const.
  test_dereference<delayed_init<const helper>>(__LINE__,
    {helper::const_get});
  test_dereference<const delayed_init<helper>>(__LINE__,
    {helper::const_get});
  test_dereference<const delayed_init<const helper>>(__LINE__,
    {helper::const_get});

  /***
   * Test conversion to bool.
   */
    
  // uninitialised.
  test_conversion_to_bool(__LINE__, d0, false);
  
  // initialised.
  test_conversion_to_bool(__LINE__, d1, true);
  
  /***
   * Test initialiser.
   */
  
  // lvalue -> uninitialised.
  test_init_uninitialised(__LINE__, {helper::constructor}, 1);
  test_init_uninitialised(__LINE__, {helper::copy_constructor}, h);
  test_init_uninitialised(__LINE__, {helper::copy_constructor}, ch);
  
  // rvalue -> uninitialised.
  test_init_uninitialised(__LINE__, {helper::constructor}, std::move(1));
  test_init_uninitialised(__LINE__, {helper::move_constructor},
    std::move(h));
  test_init_uninitialised(__LINE__, {helper::copy_constructor},
    std::move(ch));
 
  // initialised.
  test_init_initialised(__LINE__);
 
  /***
   * Test swap member.
   */

  // uninitialised <-> uninitialised.
  {
    delayed_init<helper> d1, d2;
    test_swap_member(__LINE__, d1, d2, {});
  }

  // initialised <-> uninitialised.
  {
    delayed_init<helper> d1(h), d2;
    test_swap_member(__LINE__, d1, d2,
      {helper::destructor, helper::move_constructor});
  }
  
  // initialised <-> uninitialised.
  {
    delayed_init<helper> d1, d2(h);
    test_swap_member(__LINE__, d1, d2,
      {helper::destructor, helper::move_constructor});
  }

  // initialised <-> initialised.
  {
    delayed_init<helper> d1(h), d2(h);
    test_swap_member(__LINE__, d1, d2,
      {helper::swap_member, helper::swap_non_member});
  }
  
  /***
   * Test swap non member.
   */

  // uninitialised <-> uninitialised.
  {
    delayed_init<helper> d1, d2;
    test_swap_non_member(__LINE__, d1, d2, {});
  }

  // initialised <-> uninitialised.
  {
    delayed_init<helper> d1(h), d2;
    test_swap_non_member(__LINE__, d1, d2,
      {helper::destructor, helper::move_constructor});
  }
  
  // initialised <-> uninitialised.
  {
    delayed_init<helper> d1, d2(h);
    test_swap_non_member(__LINE__, d1, d2,
      {helper::destructor, helper::move_constructor});
  }

  // initialised <-> initialised.
  {
    delayed_init<helper> d1(h), d2(h);
    test_swap_non_member(__LINE__, d1, d2,
      {helper::swap_member, helper::swap_non_member});
  }

  std::cout << "all tests passed." << std::endl;
  return 0;
}

// Assembly:
subq $0x7c8, %rsp            # imm = 0x7C8
movl $0x0, 0x7c4(%rsp)
movl $0x173, %edi            # imm = 0x173
callq 0x13b0
leaq 0x7c0(%rsp), %rdi
movq %rdi, 0xd0(%rsp)
callq 0x35f0
leaq 0x7bc(%rsp), %rdi
callq 0x35f0
movq 0xd0(%rsp), %rsi
movl $0x3, 0x7a4(%rsp)
leaq 0x7a4(%rsp), %rax
movq %rax, 0x7a8(%rsp)
movq $0x1, 0x7b0(%rsp)
movq 0x7a8(%rsp), %rcx
movq 0x7b0(%rsp), %r8
movl $0x181, %edi            # imm = 0x181
movl $0x1, %edx
callq 0x3630
jmp 0x16be
movl $0x3, 0x77c(%rsp)
leaq 0x77c(%rsp), %rax
movq %rax, 0x780(%rsp)
movq $0x1, 0x788(%rsp)
movq 0x780(%rsp), %rcx
movq 0x788(%rsp), %r8
movl $0x182, %edi            # imm = 0x182
leaq 0x7c0(%rsp), %rsi
movl $0x1, %edx
callq 0x3700
jmp 0x170e
movl $0x3, 0x764(%rsp)
leaq 0x764(%rsp), %rax
movq %rax, 0x768(%rsp)
movq $0x1, 0x770(%rsp)
movq 0x768(%rsp), %rcx
movq 0x770(%rsp), %r8
movl $0x186, %edi            # imm = 0x186
leaq 0x7bc(%rsp), %rsi
movl $0x1, %edx
callq 0x37d0
jmp 0x175e
movl $0x3, 0x74c(%rsp)
leaq 0x74c(%rsp), %rax
movq %rax, 0x750(%rsp)
movq $0x1, 0x758(%rsp)
movq 0x750(%rsp), %rcx
movq 0x758(%rsp), %r8
movl $0x187, %edi            # imm = 0x187
leaq 0x7bc(%rsp), %rsi
movl $0x1, %edx
callq 0x38a0
jmp 0x17ae
movl $0x4, 0x734(%rsp)
leaq 0x734(%rsp), %rax
movq %rax, 0x738(%rsp)
movq $0x1, 0x740(%rsp)
movq 0x738(%rsp), %rcx
movq 0x740(%rsp), %r8
movl $0x18b, %edi            # imm = 0x18B
leaq 0x7c0(%rsp), %rsi
movl $0x1, %edx
callq 0x3970
jmp 0x17fe
movl $0x4, 0x71c(%rsp)
leaq 0x71c(%rsp), %rax
movq %rax, 0x720(%rsp)
movq $0x1, 0x728(%rsp)
movq 0x720(%rsp), %rcx
movq 0x728(%rsp), %r8
movl $0x18d, %edi            # imm = 0x18D
leaq 0x7c0(%rsp), %rsi
movl $0x1, %edx
callq 0x3a40
jmp 0x184e
movl $0x3, 0x704(%rsp)
leaq 0x704(%rsp), %rax
movq %rax, 0x708(%rsp)
movq $0x1, 0x710(%rsp)
movq 0x708(%rsp), %rcx
movq 0x710(%rsp), %r8
movl $0x191, %edi            # imm = 0x191
leaq 0x7bc(%rsp), %rsi
movl $0x1, %edx
callq 0x3b10
jmp 0x189e
movl $0x3, 0x6ec(%rsp)
leaq 0x6ec(%rsp), %rax
movq %rax, 0x6f0(%rsp)
movq $0x1, 0x6f8(%rsp)
movq 0x6f0(%rsp), %rcx
movq 0x6f8(%rsp), %r8
movl $0x193, %edi            # imm = 0x193
leaq 0x7bc(%rsp), %rsi
movl $0x1, %edx
callq 0x3be0
jmp 0x18ee
leaq 0x6e4(%rsp), %rdi
movq %rdi, 0xc8(%rsp)
callq 0x3cb0
leaq 0x6dc(%rsp), %rdi
callq 0x3370
leaq 0x6d0(%rsp), %rdi
movq %rdi, 0xb0(%rsp)
movl $0x1, %esi
movl %esi, 0xbc(%rsp)
callq 0x34b0
movq 0xb0(%rsp), %rsi
leaq 0x6d4(%rsp), %rdi
callq 0x3cc0
movq 0xb0(%rsp), %rdi
callq 0x3520
movl 0xbc(%rsp), %esi
leaq 0x6c4(%rsp), %rdi
movq %rdi, 0xc0(%rsp)
callq 0x34b0
movq 0xc0(%rsp), %rsi
leaq 0x6c8(%rsp), %rdi
callq 0x34f0
movq 0xc0(%rsp), %rdi
callq 0x3520
leaq 0x6b0(%rsp), %rdi
callq 0x3470
movq 0xc8(%rsp), %rsi
movq 0x6b0(%rsp), %rcx
movq 0x6b8(%rsp), %r8
movl $0x1a4, %edi            # imm = 0x1A4
xorl %edx, %edx
callq 0x3cf0
jmp 0x19c4
leaq 0x6a0(%rsp), %rdi
callq 0x3470
movq 0x6a0(%rsp), %rcx
movq 0x6a8(%rsp), %r8
movl $0x1a5, %edi            # imm = 0x1A5
leaq 0x6e4(%rsp), %rsi
xorl %edx, %edx
callq 0x3dc0
jmp 0x19f7
leaq 0x690(%rsp), %rdi
callq 0x3470
movq 0x690(%rsp), %rcx
movq 0x698(%rsp), %r8
movl $0x1a8, %edi            # imm = 0x1A8
leaq 0x6dc(%rsp), %rsi
xorl %edx, %edx
callq 0x3e90
jmp 0x1a2a
leaq 0x680(%rsp), %rdi
callq 0x3470
movq 0x680(%rsp), %rcx
movq 0x688(%rsp), %r8
movl $0x1a9, %edi            # imm = 0x1A9
leaq 0x6dc(%rsp), %rsi
xorl %edx, %edx
callq 0x3f60
jmp 0x1a5d
movl $0x3, 0x66c(%rsp)
leaq 0x66c(%rsp), %rax
movq %rax, 0x670(%rsp)
movq $0x1, 0x678(%rsp)
movq 0x670(%rsp), %rcx
movq 0x678(%rsp), %r8
movl $0x1ac, %edi            # imm = 0x1AC
leaq 0x6d4(%rsp), %rsi
movl $0x1, %edx
callq 0x3cf0
jmp 0x1aad
movl $0x3, 0x654(%rsp)
leaq 0x654(%rsp), %rax
movq %rax, 0x658(%rsp)
movq $0x1, 0x660(%rsp)
movq 0x658(%rsp), %rcx
movq 0x660(%rsp), %r8
movl $0x1ad, %edi            # imm = 0x1AD
leaq 0x6d4(%rsp), %rsi
movl $0x1, %edx
callq 0x3dc0
jmp 0x1afd
movl $0x3, 0x63c(%rsp)
leaq 0x63c(%rsp), %rax
movq %rax, 0x640(%rsp)
movq $0x1, 0x648(%rsp)
movq 0x640(%rsp), %rcx
movq 0x648(%rsp), %r8
movl $0x1b1, %edi            # imm = 0x1B1
leaq 0x6c8(%rsp), %rsi
movl $0x1, %edx
callq 0x3e90
jmp 0x1b4d
movl $0x3, 0x624(%rsp)
leaq 0x624(%rsp), %rax
movq %rax, 0x628(%rsp)
movq $0x1, 0x630(%rsp)
movq 0x628(%rsp), %rcx
movq 0x630(%rsp), %r8
movl $0x1b2, %edi            # imm = 0x1B2
leaq 0x6c8(%rsp), %rsi
movl $0x1, %edx
callq 0x3f60
jmp 0x1b9d
leaq 0x610(%rsp), %rdi
callq 0x3470
movq 0x610(%rsp), %rcx
movq 0x618(%rsp), %r8
movl $0x1b6, %edi            # imm = 0x1B6
leaq 0x6e4(%rsp), %rsi
xorl %edx, %edx
callq 0x4030
jmp 0x1bd0
leaq 0x600(%rsp), %rdi
callq 0x3470
movq 0x600(%rsp), %rcx
movq 0x608(%rsp), %r8
movl $0x1b7, %edi            # imm = 0x1B7
leaq 0x6e4(%rsp), %rsi
xorl %edx, %edx
callq 0x4100
jmp 0x1c03
leaq 0x5f0(%rsp), %rdi
callq 0x3470
movq 0x5f0(%rsp), %rcx
movq 0x5f8(%rsp), %r8
movl $0x1ba, %edi            # imm = 0x1BA
leaq 0x6dc(%rsp), %rsi
xorl %edx, %edx
callq 0x41d0
jmp 0x1c36
leaq 0x5e0(%rsp), %rdi
callq 0x3470
movq 0x5e0(%rsp), %rcx
movq 0x5e8(%rsp), %r8
movl $0x1bb, %edi            # imm = 0x1BB
leaq 0x6dc(%rsp), %rsi
xorl %edx, %edx
callq 0x42a0
jmp 0x1c69
movl $0x4, 0x5cc(%rsp)
leaq 0x5cc(%rsp), %rax
movq %rax, 0x5d0(%rsp)
movq $0x1, 0x5d8(%rsp)
movq 0x5d0(%rsp), %rcx
movq 0x5d8(%rsp), %r8
movl $0x1be, %edi            # imm = 0x1BE
leaq 0x6d4(%rsp), %rsi
movl $0x1, %edx
callq 0x4030
jmp 0x1cb9
movl $0x4, 0x5b4(%rsp)
leaq 0x5b4(%rsp), %rax
movq %rax, 0x5b8(%rsp)
movq $0x1, 0x5c0(%rsp)
movq 0x5b8(%rsp), %rcx
movq 0x5c0(%rsp), %r8
movl $0x1c0, %edi            # imm = 0x1C0
leaq 0x6d4(%rsp), %rsi
movl $0x1, %edx
callq 0x4100
jmp 0x1d09
movl $0x3, 0x59c(%rsp)
leaq 0x59c(%rsp), %rax
movq %rax, 0x5a0(%rsp)
movq $0x1, 0x5a8(%rsp)
movq 0x5a0(%rsp), %rcx
movq 0x5a8(%rsp), %r8
movl $0x1c4, %edi            # imm = 0x1C4
leaq 0x6c8(%rsp), %rsi
movl $0x1, %edx
callq 0x41d0
jmp 0x1d59
movl $0x3, 0x584(%rsp)
leaq 0x584(%rsp), %rax
movq %rax, 0x588(%rsp)
movq $0x1, 0x590(%rsp)
movq 0x588(%rsp), %rcx
movq 0x590(%rsp), %r8
movl $0x1c6, %edi            # imm = 0x1C6
leaq 0x6c8(%rsp), %rsi
movl $0x1, %edx
callq 0x42a0
jmp 0x1da9
leaq 0x570(%rsp), %rdi
callq 0x3470
movq 0x570(%rsp), %rdx
movq 0x578(%rsp), %rcx
movl $0x1ce, %edi            # imm = 0x1CE
leaq 0x6e4(%rsp), %rsi
callq 0x4370
jmp 0x1dda
movl $0x5, 0x55c(%rsp)
leaq 0x55c(%rsp), %rax
movq %rax, 0x560(%rsp)
movq $0x1, 0x568(%rsp)
movq 0x560(%rsp), %rdx
movq 0x568(%rsp), %rcx
movl $0x1d1, %edi            # imm = 0x1D1
leaq 0x6d4(%rsp), %rsi
callq 0x4370
jmp 0x1e25
movl $0x3, 0x544(%rsp)
leaq 0x544(%rsp), %rax
movq %rax, 0x548(%rsp)
movq $0x1, 0x550(%rsp)
movq 0x548(%rsp), %r8
movq 0x550(%rsp), %r9
movl $0x1d8, %edi            # imm = 0x1D8
leaq 0x7c0(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x4400
jmp 0x1e7d
movl $0x6, 0x52c(%rsp)
leaq 0x52c(%rsp), %rax
movq %rax, 0x530(%rsp)
movq $0x1, 0x538(%rsp)
movq 0x530(%rsp), %r8
movq 0x538(%rsp), %r9
movl $0x1db, %edi            # imm = 0x1DB
leaq 0x7c0(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
callq 0x4400
jmp 0x1ed5
movl $0x3, 0x514(%rsp)
leaq 0x514(%rsp), %rax
movq %rax, 0x518(%rsp)
movq $0x1, 0x520(%rsp)
movq 0x518(%rsp), %r8
movq 0x520(%rsp), %r9
movl $0x1de, %edi            # imm = 0x1DE
leaq 0x7bc(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x44f0
jmp 0x1f2d
movl $0x6, 0x4fc(%rsp)
leaq 0x4fc(%rsp), %rax
movq %rax, 0x500(%rsp)
movq $0x1, 0x508(%rsp)
movq 0x500(%rsp), %r8
movq 0x508(%rsp), %r9
movl $0x1e1, %edi            # imm = 0x1E1
leaq 0x7bc(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
callq 0x44f0
jmp 0x1f85
movl $0x4, 0x4e4(%rsp)
leaq 0x4e4(%rsp), %rax
movq %rax, 0x4e8(%rsp)
movq $0x1, 0x4f0(%rsp)
movq 0x4e8(%rsp), %r8
movq 0x4f0(%rsp), %r9
movl $0x1e4, %edi            # imm = 0x1E4
leaq 0x7c0(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x45e0
jmp 0x1fdd
movl $0x7, 0x4cc(%rsp)
leaq 0x4cc(%rsp), %rax
movq %rax, 0x4d0(%rsp)
movq $0x1, 0x4d8(%rsp)
movq 0x4d0(%rsp), %r8
movq 0x4d8(%rsp), %r9
movl $0x1e8, %edi            # imm = 0x1E8
leaq 0x7c0(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
callq 0x45e0
jmp 0x2035
movl $0x3, 0x4b4(%rsp)
leaq 0x4b4(%rsp), %rax
movq %rax, 0x4b8(%rsp)
movq $0x1, 0x4c0(%rsp)
movq 0x4b8(%rsp), %r8
movq 0x4c0(%rsp), %r9
movl $0x1ec, %edi            # imm = 0x1EC
leaq 0x7bc(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x46d0
jmp 0x208d
movl $0x6, 0x49c(%rsp)
leaq 0x49c(%rsp), %rax
movq %rax, 0x4a0(%rsp)
movq $0x1, 0x4a8(%rsp)
movq 0x4a0(%rsp), %r8
movq 0x4a8(%rsp), %r9
movl $0x1f0, %edi            # imm = 0x1F0
leaq 0x7bc(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
callq 0x46d0
jmp 0x20e5
leaq 0x488(%rsp), %rdi
callq 0x3470
movq 0x488(%rsp), %r8
movq 0x490(%rsp), %r9
movl $0x1f8, %edi            # imm = 0x1F8
leaq 0x6e4(%rsp), %rdx
xorl %ecx, %ecx
movq %rdx, %rsi
callq 0x47c0
jmp 0x211b
movl $0x5, 0x474(%rsp)
leaq 0x474(%rsp), %rax
movq %rax, 0x478(%rsp)
movq $0x1, 0x480(%rsp)
movq 0x478(%rsp), %r8
movq 0x480(%rsp), %r9
movl $0x1fb, %edi            # imm = 0x1FB
leaq 0x6e4(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
xorl %ecx, %ecx
callq 0x47c0
jmp 0x2170
leaq 0x460(%rsp), %rdi
callq 0x3470
movq 0x460(%rsp), %r8
movq 0x468(%rsp), %r9
movl $0x1fe, %edi            # imm = 0x1FE
leaq 0x6dc(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
xorl %ecx, %ecx
callq 0x48b0
jmp 0x21ab
movl $0x5, 0x44c(%rsp)
leaq 0x44c(%rsp), %rax
movq %rax, 0x450(%rsp)
movq $0x1, 0x458(%rsp)
movq 0x450(%rsp), %r8
movq 0x458(%rsp), %r9
movl $0x201, %edi            # imm = 0x201
leaq 0x6dc(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
xorl %ecx, %ecx
callq 0x48b0
jmp 0x2200
leaq 0x438(%rsp), %rdi
callq 0x3470
movq 0x438(%rsp), %r8
movq 0x440(%rsp), %r9
movl $0x204, %edi            # imm = 0x204
leaq 0x6e4(%rsp), %rdx
xorl %ecx, %ecx
movq %rdx, %rsi
callq 0x49a0
jmp 0x2236
movl $0x5, 0x424(%rsp)
leaq 0x424(%rsp), %rax
movq %rax, 0x428(%rsp)
movq $0x1, 0x430(%rsp)
movq 0x428(%rsp), %r8
movq 0x430(%rsp), %r9
movl $0x207, %edi            # imm = 0x207
leaq 0x6e4(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
xorl %ecx, %ecx
callq 0x49a0
jmp 0x228b
leaq 0x410(%rsp), %rdi
callq 0x3470
movq 0x410(%rsp), %r8
movq 0x418(%rsp), %r9
movl $0x20a, %edi            # imm = 0x20A
leaq 0x6dc(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
xorl %ecx, %ecx
callq 0x4a90
jmp 0x22c6
movl $0x5, 0x3fc(%rsp)
leaq 0x3fc(%rsp), %rax
movq %rax, 0x400(%rsp)
movq $0x1, 0x408(%rsp)
movq 0x400(%rsp), %r8
movq 0x408(%rsp), %r9
movl $0x20d, %edi            # imm = 0x20D
leaq 0x6dc(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
xorl %ecx, %ecx
callq 0x4a90
jmp 0x231b
movl $0x3, 0x3e4(%rsp)
leaq 0x3e4(%rsp), %rax
movq %rax, 0x3e8(%rsp)
movq $0x1, 0x3f0(%rsp)
movq 0x3e8(%rsp), %r8
movq 0x3f0(%rsp), %r9
movl $0x215, %edi            # imm = 0x215
leaq 0x6d4(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x47c0
jmp 0x2373
movl $0x6, 0x3cc(%rsp)
leaq 0x3cc(%rsp), %rax
movq %rax, 0x3d0(%rsp)
movq $0x1, 0x3d8(%rsp)
movq 0x3d0(%rsp), %r8
movq 0x3d8(%rsp), %r9
movl $0x218, %edi            # imm = 0x218
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x47c0
jmp 0x23c6
movl $0x3, 0x3b4(%rsp)
leaq 0x3b4(%rsp), %rax
movq %rax, 0x3b8(%rsp)
movq $0x1, 0x3c0(%rsp)
movq 0x3b8(%rsp), %r8
movq 0x3c0(%rsp), %r9
movl $0x21b, %edi            # imm = 0x21B
leaq 0x6c8(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x48b0
jmp 0x241e
movl $0x6, 0x39c(%rsp)
leaq 0x39c(%rsp), %rax
movq %rax, 0x3a0(%rsp)
movq $0x1, 0x3a8(%rsp)
movq 0x3a0(%rsp), %r8
movq 0x3a8(%rsp), %r9
movl $0x21e, %edi            # imm = 0x21E
leaq 0x6c8(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
callq 0x48b0
jmp 0x2476
movl $0x4, 0x384(%rsp)
leaq 0x384(%rsp), %rax
movq %rax, 0x388(%rsp)
movq $0x1, 0x390(%rsp)
movq 0x388(%rsp), %r8
movq 0x390(%rsp), %r9
movl $0x221, %edi            # imm = 0x221
leaq 0x6d4(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x49a0
jmp 0x24ce
movl $0x7, 0x36c(%rsp)
leaq 0x36c(%rsp), %rax
movq %rax, 0x370(%rsp)
movq $0x1, 0x378(%rsp)
movq 0x370(%rsp), %r8
movq 0x378(%rsp), %r9
movl $0x225, %edi            # imm = 0x225
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
movq %rdx, %rsi
callq 0x49a0
jmp 0x2521
movl $0x3, 0x354(%rsp)
leaq 0x354(%rsp), %rax
movq %rax, 0x358(%rsp)
movq $0x1, 0x360(%rsp)
movq 0x358(%rsp), %r8
movq 0x360(%rsp), %r9
movl $0x229, %edi            # imm = 0x229
leaq 0x6c8(%rsp), %rsi
leaq 0x6e4(%rsp), %rdx
movl $0x1, %ecx
callq 0x4a90
jmp 0x2579
movl $0x6, 0x33c(%rsp)
leaq 0x33c(%rsp), %rax
movq %rax, 0x340(%rsp)
movq $0x1, 0x348(%rsp)
movq 0x340(%rsp), %r8
movq 0x348(%rsp), %r9
movl $0x22d, %edi            # imm = 0x22D
leaq 0x6c8(%rsp), %rsi
leaq 0x6d4(%rsp), %rdx
movl $0x1, %ecx
callq 0x4a90
jmp 0x25d1
movl $0x234, %edi            # imm = 0x234
callq 0x4b80
jmp 0x25dd
movl $0x235, %edi            # imm = 0x235
callq 0x4c90
jmp 0x25e9
movl $0xa, 0x324(%rsp)
leaq 0x324(%rsp), %rax
movq %rax, 0x328(%rsp)
movq $0x1, 0x330(%rsp)
movq 0x328(%rsp), %rsi
movq 0x330(%rsp), %rdx
movl $0x23b, %edi            # imm = 0x23B
callq 0x4da0
jmp 0x262c
movl $0x9, 0x30c(%rsp)
leaq 0x30c(%rsp), %rax
movq %rax, 0x310(%rsp)
movq $0x1, 0x318(%rsp)
movq 0x310(%rsp), %rsi
movq 0x318(%rsp), %rdx
movl $0x23d, %edi            # imm = 0x23D
callq 0x4e60
jmp 0x266f
movl $0x245, %edi            # imm = 0x245
leaq 0x6e4(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4f20
jmp 0x2687
movl $0x248, %edi            # imm = 0x248
leaq 0x6e4(%rsp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x5030
jmp 0x26a2
movl $0x249, %edi            # imm = 0x249
leaq 0x6e4(%rsp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x5140
jmp 0x26bd
movl $0x24a, %edi            # imm = 0x24A
leaq 0x6e4(%rsp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x5220
jmp 0x26d8
movl $0x251, %edi            # imm = 0x251
leaq 0x6d4(%rsp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x4f20
jmp 0x26f3
movl $0x254, %edi            # imm = 0x254
leaq 0x6d4(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x5140
jmp 0x270e
movl $0x255, %edi            # imm = 0x255
leaq 0x6d4(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x5030
jmp 0x2729
movl $0x256, %edi            # imm = 0x256
leaq 0x6d4(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x5220
jmp 0x2744
movl $0xa, 0x2f4(%rsp)
leaq 0x2f4(%rsp), %rax
movq %rax, 0x2f8(%rsp)
movq $0x1, 0x300(%rsp)
movq 0x2f8(%rsp), %rsi
movq 0x300(%rsp), %rdx
movl $0x25d, %edi            # imm = 0x25D
callq 0x5300
jmp 0x2787
movl $0x9, 0x2dc(%rsp)
leaq 0x2dc(%rsp), %rax
movq %rax, 0x2e0(%rsp)
movq $0x1, 0x2e8(%rsp)
movq 0x2e0(%rsp), %rsi
movq 0x2e8(%rsp), %rdx
movl $0x260, %edi            # imm = 0x260
callq 0x53c0
jmp 0x27ca
movl $0x9, 0x2c4(%rsp)
leaq 0x2c4(%rsp), %rax
movq %rax, 0x2c8(%rsp)
movq $0x1, 0x2d0(%rsp)
movq 0x2c8(%rsp), %rsi
movq 0x2d0(%rsp), %rdx
movl $0x262, %edi            # imm = 0x262
callq 0x5480
jmp 0x280d
movl $0x9, 0x2ac(%rsp)
leaq 0x2ac(%rsp), %rax
movq %rax, 0x2b0(%rsp)
movq $0x1, 0x2b8(%rsp)
movq 0x2b0(%rsp), %rsi
movq 0x2b8(%rsp), %rdx
movl $0x264, %edi            # imm = 0x264
callq 0x5540
jmp 0x2850
leaq 0x2a4(%rsp), %rdi
movq %rdi, 0xa8(%rsp)
leaq 0x6e4(%rsp), %rsi
callq 0x5600
movq 0xa8(%rsp), %rsi
movl $0x26c, %edi            # imm = 0x26C
xorl %edx, %edx
callq 0x1460
jmp 0x2883
leaq 0x2a4(%rsp), %rdi
callq 0x34a0
leaq 0x29c(%rsp), %rdi
movq %rdi, 0xa0(%rsp)
leaq 0x6d4(%rsp), %rsi
callq 0x5600
movq 0xa0(%rsp), %rsi
movl $0x26f, %edi            # imm = 0x26F
movl $0x1, %edx
callq 0x1460
jmp 0x28c6
leaq 0x29c(%rsp), %rdi
callq 0x34a0
movl $0x2, 0x284(%rsp)
leaq 0x284(%rsp), %rax
movq %rax, 0x288(%rsp)
movq $0x1, 0x290(%rsp)
movl $0x1, 0x280(%rsp)
movq 0x288(%rsp), %rsi
movq 0x290(%rsp), %rdx
movl $0x276, %edi            # imm = 0x276
leaq 0x280(%rsp), %rcx
callq 0x5650
jmp 0x2929
movl $0x3, 0x26c(%rsp)
leaq 0x26c(%rsp), %rax
movq %rax, 0x270(%rsp)
movq $0x1, 0x278(%rsp)
movq 0x270(%rsp), %rsi
movq 0x278(%rsp), %rdx
movl $0x277, %edi            # imm = 0x277
leaq 0x7c0(%rsp), %rcx
callq 0x5750
jmp 0x2974
movl $0x3, 0x254(%rsp)
leaq 0x254(%rsp), %rax
movq %rax, 0x258(%rsp)
movq $0x1, 0x260(%rsp)
movq 0x258(%rsp), %rsi
movq 0x260(%rsp), %rdx
movl $0x278, %edi            # imm = 0x278
leaq 0x7bc(%rsp), %rcx
callq 0x5850
jmp 0x29bf
movl $0x2, 0x23c(%rsp)
leaq 0x23c(%rsp), %rax
movq %rax, 0x240(%rsp)
movq $0x1, 0x248(%rsp)
movl $0x1, 0x238(%rsp)
movq 0x240(%rsp), %rsi
movq 0x248(%rsp), %rdx
movl $0x27b, %edi            # imm = 0x27B
leaq 0x238(%rsp), %rcx
callq 0x5650
jmp 0x2a15
movl $0x4, 0x224(%rsp)
leaq 0x224(%rsp), %rax
movq %rax, 0x228(%rsp)
movq $0x1, 0x230(%rsp)
movq 0x228(%rsp), %rsi
movq 0x230(%rsp), %rdx
movl $0x27c, %edi            # imm = 0x27C
leaq 0x7c0(%rsp), %rcx
callq 0x5950
jmp 0x2a60
movl $0x3, 0x20c(%rsp)
leaq 0x20c(%rsp), %rax
movq %rax, 0x210(%rsp)
movq $0x1, 0x218(%rsp)
movq 0x210(%rsp), %rsi
movq 0x218(%rsp), %rdx
movl $0x27e, %edi            # imm = 0x27E
leaq 0x7bc(%rsp), %rcx
callq 0x5a50
jmp 0x2aab
movl $0x282, %edi            # imm = 0x282
callq 0x14f0
jmp 0x2ab7
leaq 0x204(%rsp), %rdi
movq %rdi, 0x90(%rsp)
callq 0x3cb0
leaq 0x1fc(%rsp), %rdi
movq %rdi, 0x98(%rsp)
callq 0x3cb0
leaq 0x1e8(%rsp), %rdi
callq 0x3470
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq 0x1e8(%rsp), %rcx
movq 0x1f0(%rsp), %r8
movl $0x28b, %edi            # imm = 0x28B
callq 0x5b50
jmp 0x2b1a
leaq 0x1fc(%rsp), %rdi
callq 0x5c60
leaq 0x204(%rsp), %rdi
callq 0x5c60
leaq 0x1e0(%rsp), %rdi
movq %rdi, 0x80(%rsp)
leaq 0x7c0(%rsp), %rsi
callq 0x5c70
leaq 0x1d8(%rsp), %rdi
movq %rdi, 0x88(%rsp)
callq 0x3cb0
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movl $0x5, 0x1c0(%rsp)
movl $0x4, 0x1c4(%rsp)
leaq 0x1c0(%rsp), %rax
movq %rax, 0x1c8(%rsp)
movq $0x2, 0x1d0(%rsp)
movq 0x1c8(%rsp), %rcx
movq 0x1d0(%rsp), %r8
movl $0x291, %edi            # imm = 0x291
callq 0x5b50
jmp 0x2bc4
leaq 0x1d8(%rsp), %rdi
callq 0x5c60
leaq 0x1e0(%rsp), %rdi
callq 0x5c60
leaq 0x1b8(%rsp), %rdi
movq %rdi, 0x70(%rsp)
callq 0x3cb0
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x78(%rsp)
leaq 0x7c0(%rsp), %rsi
callq 0x5c70
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
movl $0x5, 0x198(%rsp)
movl $0x4, 0x19c(%rsp)
leaq 0x198(%rsp), %rax
movq %rax, 0x1a0(%rsp)
movq $0x2, 0x1a8(%rsp)
movq 0x1a0(%rsp), %rcx
movq 0x1a8(%rsp), %r8
movl $0x298, %edi            # imm = 0x298
callq 0x5b50
jmp 0x2c62
leaq 0x1b0(%rsp), %rdi
callq 0x5c60
leaq 0x1b8(%rsp), %rdi
callq 0x5c60
leaq 0x190(%rsp), %rdi
movq %rdi, 0x60(%rsp)
leaq 0x7c0(%rsp), %rsi
movq %rsi, 0x58(%rsp)
callq 0x5c70
movq 0x58(%rsp), %rsi
leaq 0x188(%rsp), %rdi
movq %rdi, 0x68(%rsp)
callq 0x5c70
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movl $0xb, 0x170(%rsp)
movl $0xc, 0x174(%rsp)
leaq 0x170(%rsp), %rax
movq %rax, 0x178(%rsp)
movq $0x2, 0x180(%rsp)
movq 0x178(%rsp), %rcx
movq 0x180(%rsp), %r8
movl $0x29f, %edi            # imm = 0x29F
callq 0x5b50
jmp 0x2d0a
leaq 0x188(%rsp), %rdi
callq 0x5c60
leaq 0x190(%rsp), %rdi
callq 0x5c60
leaq 0x168(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x3cb0
leaq 0x160(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x3cb0
leaq 0x150(%rsp), %rdi
callq 0x3470
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x150(%rsp), %rcx
movq 0x158(%rsp), %r8
movl $0x2aa, %edi            # imm = 0x2AA
callq 0x5ca0
jmp 0x2d7b
leaq 0x160(%rsp), %rdi
callq 0x5c60
leaq 0x168(%rsp), %rdi
callq 0x5c60
leaq 0x148(%rsp), %rdi
movq %rdi, 0x38(%rsp)
leaq 0x7c0(%rsp), %rsi
callq 0x5c70
leaq 0x140(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x3cb0
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movl $0x5, 0x128(%rsp)
movl $0x4, 0x12c(%rsp)
leaq 0x128(%rsp), %rax
movq %rax, 0x130(%rsp)
movq $0x2, 0x138(%rsp)
movq 0x130(%rsp), %rcx
movq 0x138(%rsp), %r8
movl $0x2b0, %edi            # imm = 0x2B0
callq 0x5ca0
jmp 0x2e19
leaq 0x140(%rsp), %rdi
callq 0x5c60
leaq 0x148(%rsp), %rdi
callq 0x5c60
leaq 0x120(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3cb0
leaq 0x118(%rsp), %rdi
movq %rdi, 0x30(%rsp)
leaq 0x7c0(%rsp), %rsi
callq 0x5c70
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl $0x5, 0x100(%rsp)
movl $0x4, 0x104(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x108(%rsp)
movq $0x2, 0x110(%rsp)
movq 0x108(%rsp), %rcx
movq 0x110(%rsp), %r8
movl $0x2b7, %edi            # imm = 0x2B7
callq 0x5ca0
jmp 0x2eb7
leaq 0x118(%rsp), %rdi
callq 0x5c60
leaq 0x120(%rsp), %rdi
callq 0x5c60
leaq 0xf8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x7c0(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x5c70
movq 0x10(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5c70
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl $0xb, 0xd8(%rsp)
movl $0xc, 0xdc(%rsp)
leaq 0xd8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq $0x2, 0xe8(%rsp)
movq 0xe0(%rsp), %rcx
movq 0xe8(%rsp), %r8
movl $0x2be, %edi            # imm = 0x2BE
callq 0x5ca0
jmp 0x2f5f
leaq 0xf0(%rsp), %rdi
callq 0x5c60
leaq 0xf8(%rsp), %rdi
callq 0x5c60
movq 0xb050(%rip), %rdi      # 0xdfd0
leaq 0x6197(%rip), %rsi      # 0x911e
callq 0x10e0
movq %rax, 0x8(%rsp)
jmp 0x2f93
movq 0x8(%rsp), %rdi
movq 0xb019(%rip), %rsi      # 0xdfb8
callq 0x1100
jmp 0x2fa6
movl $0x0, 0x7c4(%rsp)
leaq 0x6c8(%rsp), %rdi
callq 0x34a0
leaq 0x6d4(%rsp), %rdi
callq 0x5c60
leaq 0x6dc(%rsp), %rdi
callq 0x34a0
leaq 0x6e4(%rsp), %rdi
callq 0x5c60
leaq 0x7bc(%rsp), %rdi
callq 0x3520
leaq 0x7c0(%rsp), %rdi
callq 0x3520
movl 0x7c4(%rsp), %eax
addq $0x7c8, %rsp            # imm = 0x7C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
jmp 0x324d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x2a4(%rsp), %rdi
callq 0x34a0
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x29c(%rsp), %rdi
callq 0x34a0
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x1fc(%rsp), %rdi
callq 0x5c60
leaq 0x204(%rsp), %rdi
callq 0x5c60
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x1d8(%rsp), %rdi
callq 0x5c60
leaq 0x1e0(%rsp), %rdi
callq 0x5c60
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x5c60
leaq 0x1b8(%rsp), %rdi
callq 0x5c60
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x188(%rsp), %rdi
callq 0x5c60
leaq 0x190(%rsp), %rdi
callq 0x5c60
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x160(%rsp), %rdi
callq 0x5c60
leaq 0x168(%rsp), %rdi
callq 0x5c60
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x140(%rsp), %rdi
callq 0x5c60
leaq 0x148(%rsp), %rdi
callq 0x5c60
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0x118(%rsp), %rdi
callq 0x5c60
leaq 0x120(%rsp), %rdi
callq 0x5c60
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x798(%rsp)
movl %eax, 0x794(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x5c60
leaq 0xf8(%rsp), %rdi
callq 0x5c60
leaq 0x6c8(%rsp), %rdi
callq 0x34a0
leaq 0x6d4(%rsp), %rdi
callq 0x5c60
leaq 0x6dc(%rsp), %rdi
callq 0x34a0
leaq 0x6e4(%rsp), %rdi
callq 0x5c60
leaq 0x7bc(%rsp), %rdi
callq 0x3520
leaq 0x7c0(%rsp), %rdi
callq 0x3520
movq 0x798(%rsp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
nop