LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_chunky_copy_body()
TEST(image_chunky_copy) {
  test_copy_all_types<chunky_image_shape<1>, chunky_image_shape<1>>(1);
  test_copy_all_types<chunky_image_shape<2>, chunky_image_shape<2>>(2);
  test_copy_all_types<chunky_image_shape<3>, chunky_image_shape<3>>(3);
  test_copy_all_types<chunky_image_shape<4>, chunky_image_shape<4>>(4);
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x62d52
movl $0x1, %edi
callq 0x63165
movl $0x1, %edi
callq 0x63577
movl $0x2, %edi
callq 0x6533a
movl $0x2, %edi
callq 0x6574d
movl $0x2, %edi
callq 0x65b5f
movl $0x3, %edi
callq 0x67da6
movl $0x3, %edi
callq 0x681b9
movl $0x3, %edi
callq 0x685cb
movl $0x4, %edi
callq 0x6a1b6
movl $0x4, %edi
callq 0x6a5c9
movl $0x4, %edi
popq %rax
jmp 0x6a9db
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_interleave_body()
TEST(image_interleave) {
  test_copy_all_types<planar_image_shape, chunky_image_shape<1>>(1);
  test_copy_all_types<planar_image_shape, chunky_image_shape<2>>(2);
  test_copy_all_types<planar_image_shape, chunky_image_shape<3>>(3);
  test_copy_all_types<planar_image_shape, chunky_image_shape<4>>(4);
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x6e37b
movl $0x1, %edi
callq 0x6e742
movl $0x1, %edi
callq 0x6eb08
movl $0x2, %edi
callq 0x6f512
movl $0x2, %edi
callq 0x6f8d9
movl $0x2, %edi
callq 0x6fc9f
movl $0x3, %edi
callq 0x706b8
movl $0x3, %edi
callq 0x70a7f
movl $0x3, %edi
callq 0x70e45
movl $0x4, %edi
callq 0x71861
movl $0x4, %edi
callq 0x71c28
movl $0x4, %edi
popq %rax
jmp 0x71fee
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_deinterleave_body()
TEST(image_deinterleave) {
  test_copy_all_types<chunky_image_shape<1>, planar_image_shape>(1);
  test_copy_all_types<chunky_image_shape<2>, planar_image_shape>(2);
  test_copy_all_types<chunky_image_shape<3>, planar_image_shape>(3);
  test_copy_all_types<chunky_image_shape<4>, planar_image_shape>(4);
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x72a0a
movl $0x1, %edi
callq 0x72d8b
movl $0x1, %edi
callq 0x7310b
movl $0x2, %edi
callq 0x73bbc
movl $0x2, %edi
callq 0x73f3d
movl $0x2, %edi
callq 0x742bd
movl $0x3, %edi
callq 0x74d7d
movl $0x3, %edi
callq 0x750fe
movl $0x3, %edi
callq 0x7547e
movl $0x4, %edi
callq 0x75f3e
movl $0x4, %edi
callq 0x762bf
movl $0x4, %edi
popq %rax
jmp 0x7663f
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_overload_shape_body()
TEST(image_overload_shape) {
  planar_image<int> planar({10, 20, 3});
  chunky_image<int> chunky({10, 20, 3});

  overload_shape(planar);
  overload_shape(chunky);

  chunky_image<int, 3> chunky3({10, 20, {}});
  general_chunky(chunky3.cref());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
xorl %r12d, %r12d
leaq 0x40(%rsp), %rbx
movq %r12, (%rbx)
movl $0xa, %eax
movq %rax, 0x8(%rbx)
movq %r15, 0x10(%rbx)
xorl %edi, %edi
movq %rbx, %rsi
callq 0xd133
xorps %xmm0, %xmm0
leaq 0x100(%rsp), %r14
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movl $0x3, %ebp
movq %rbp, 0x28(%r14)
movq %r15, 0x30(%r14)
movq %r12, 0x38(%r14)
movl $0x14, %r13d
movq %r13, 0x40(%r14)
movq %r15, 0x48(%r14)
movq %r12, 0x50(%r14)
movl $0xa, %eax
movq %rax, 0x58(%r14)
movq %r14, %rdi
callq 0xc30a
movq %r14, %rdi
callq 0xc412
leaq 0xa8(%rsp), %rsi
movq %r12, (%rsi)
movq %rbp, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movl $0x2, %edi
callq 0x4baaf
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %r12, 0x18(%rbx)
movq %rbp, 0x28(%rbx)
movq %r12, 0x38(%rbx)
movq %r13, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movq %r12, 0x50(%rbx)
movl $0xa, %eax
movq %rax, 0x58(%rbx)
movq %r15, 0x60(%rbx)
leaq 0x40(%rsp), %rdi
callq 0x77e46
leaq 0x40(%rsp), %rdi
callq 0x77f52
xorl %eax, %eax
leaq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq $0x14, 0x10(%rdi)
movq %r15, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0xa, 0x28(%rdi)
callq 0x784fe
movq 0x38(%rsp), %rax
leaq 0xa8(%rsp), %rdi
movq %rax, 0x50(%rdi)
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x40(%rdi)
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x78546
leaq 0xa8(%rsp), %rdi
callq 0x78612
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq $0x3, 0x8(%rsi)
movq $0x1, 0x10(%rsi)
movl $0x2, %edi
callq 0x4baaf
leaq 0xa8(%rsp), %rdi
callq 0x78744
leaq 0x40(%rsp), %rdi
callq 0x783ba
leaq 0x100(%rsp), %rdi
callq 0xd206
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c897
jmp 0x5c897
jmp 0x5c897
movq %rax, %rbx
jmp 0x5c880
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x783ba
leaq 0x100(%rsp), %rdi
callq 0xd206
movq %rbx, %rdi
callq 0x2300
jmp 0x5c897
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_overload_chunky_body()
TEST(image_overload_chunky) {
  chunky_image<int, 1> chunky1({10, 20, {}});
  chunky_image<int, 3> chunky3({10, 20, {}});

  overload_chunky(chunky1);
  overload_chunky(chunky3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
xorl %r15d, %r15d
leaq 0x38(%rsp), %rbx
movq %r15, 0x8(%rbx)
movl $0x14, %r12d
movq %r12, 0x10(%rbx)
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq %r13, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movl $0xa, %ebp
movq %rbp, 0x28(%rbx)
movq %rbx, %rdi
callq 0x7884c
movq 0x30(%rbx), %rax
leaq 0x90(%rsp), %r14
movq %rax, 0x50(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x40(%r14)
movups %xmm1, 0x30(%r14)
movups %xmm0, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r15, 0x18(%r14)
movq %r14, %rdi
callq 0x78890
movq %r14, %rdi
callq 0x78958
movq %rsp, %rdi
movq %r15, 0x8(%rdi)
movq %r12, 0x10(%rdi)
movq %r13, 0x18(%rdi)
movq %r15, 0x20(%rdi)
movq %rbp, 0x28(%rdi)
callq 0x784fe
movq 0x30(%rsp), %rax
leaq 0x38(%rsp), %rdi
movq %rax, 0x50(%rdi)
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups 0x20(%rsp), %xmm2
movups %xmm2, 0x40(%rdi)
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x78546
leaq 0x38(%rsp), %rdi
callq 0x78612
leaq 0x38(%rsp), %rdi
callq 0x78744
leaq 0x90(%rsp), %rdi
callq 0x78a80
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5c9d8
jmp 0x5c9d8
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x78a80
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/include/array/image.h
// Function: nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>> nda::crop<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>>(nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>> const&, long, long, long, long, nda::crop_origin)
array_ref<T, Shape> crop(const array_ref<T, Shape>& im, index_t x0, index_t y0, index_t x1,
    index_t y1, crop_origin origin = crop_origin::crop) {
  x0 = internal::max(x0, im.x().min());
  y0 = internal::max(y0, im.y().min());
  x1 = internal::min(x1, im.x().max() + 1);
  y1 = internal::min(y1, im.y().max() + 1);
  Shape cropped_shape = crop_image_shape(im.shape(), x0, y0, x1, y1, origin);
  index_t c0 = im.c().min();
  T* base = im.base() != nullptr ? &im(x0, y0, c0) : nullptr;
  if (origin == crop_origin::crop) {
    base = internal::pointer_add(base, -cropped_shape(x0, y0, c0));
  }
  return array_ref<T, Shape>(base, cropped_shape);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rsi), %r15
cmpq %rdx, %r15
cmovgq %r15, %rdx
movq 0x10(%rsi), %r12
cmpq %rcx, %r12
cmovgq %r12, %rcx
movl 0x40(%rsp), %r11d
movq 0x30(%rsi), %rax
addq %r15, %rax
cmpq %r8, %rax
cmovgeq %r8, %rax
movq 0x18(%rsi), %rdi
addq %r12, %rdi
cmpq %r9, %rdi
cmovgeq %r9, %rdi
testl %r11d, %r11d
je 0x6168d
movq %r15, %r8
movq %r12, %r9
cmpl $0x1, %r11d
jne 0x61693
movq %rdx, %r8
movq %rcx, %r9
jmp 0x61693
xorl %r8d, %r8d
xorl %r9d, %r9d
movq 0x8(%rsi), %r14
movq 0x20(%rsi), %r10
movq (%rsi), %r13
testq %r13, %r13
je 0x616cf
movq %rdx, %rbp
subq %r15, %rbp
movq %rcx, %r15
subq %r12, %r15
imulq %r10, %r15
leaq (,%rbp,2), %r12
addq %rbp, %r12
leaq (,%r12,4), %r12
addq %r13, %r12
leaq (%r12,%r15,4), %r15
jmp 0x616d2
xorl %r15d, %r15d
movq 0x38(%rsi), %rsi
subq %rdx, %rax
subq %rcx, %rdi
cmpl $0x1, %r11d
jne 0x61701
subq %r8, %rdx
leaq (%rdx,%rdx,2), %rdx
movq %r9, %r11
subq %rcx, %r11
imulq %r10, %r11
subq %rdx, %r11
testq %r15, %r15
leaq (%r15,%r11,4), %rcx
cmovneq %rcx, %r15
movq %r15, (%rbx)
movw %r14w, 0x8(%rbx)
shrl $0x10, %r14d
movb %r14b, 0xa(%rbx)
movq %r9, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
movq %r10, 0x20(%rbx)
movq %r8, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rsi, 0x38(%rbx)
negq %r10
jno 0x6173b
leaq 0x8(%rbx), %rsi
callq 0x61c30
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/include/array/image.h
// Function: void nda::for_each_image_index<nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>, void nda::check_pattern<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>>(nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>> const&, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>::index_type const&)::'lambda'(std::tuple<long, long, long> const&)&>(int const&, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>&&)
void for_each_image_index(const Shape& s, Fn&& fn) {
  // Images should always be iterated with c as the innermost loop. Even when
  // the image is planar, the number of channels is generally small, and many
  // operations use all of the channels at the same time (all-to-all
  // communication in the c dimension).
  for (index_t y : s.y()) {
    for (index_t x : s.x()) {
      for (index_t c : s.c()) {
        fn(std::tuple<index_t, index_t, index_t>(x, y, c));
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x619c8
movq %rsi, %rbx
movq (%rsp), %rax
movq 0x8(%rax), %r13
addq %r13, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq (%rsp), %rax
movq 0x28(%rax), %rbp
testq %rbp, %rbp
je 0x619be
movq (%rsp), %rax
movq 0x20(%rax), %r12
addq %r12, %rbp
xorl %r14d, %r14d
movq %r14, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x619d8
incq %r14
cmpq $0x3, %r14
jne 0x61993
incq %r12
cmpq %rbp, %r12
jne 0x61990
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x61978
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/main.cpp
// Function: (anonymous namespace)::wildcard_match(char const*, char const*)
bool wildcard_match(const char* p, const char* str) {
  while (*p && *str && (*p == *str || *p == '?') && *p != '*') {
    str++;
    p++;
  }

  if (!*p) {
    return *str == 0;
  } else if (*p == '*') {
    p++;
    do {
      if (wildcard_match(p, str)) { return true; }
    } while (*str++);
  }
  return !*p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x78f99
movq %rdi, %r14
incq %r14
movb (%rbx), %cl
testb %cl, %cl
je 0x78f7a
cmpb %cl, %al
setne %cl
cmpb $0x3f, %al
setne %dl
testb %cl, %dl
jne 0x78f7a
cmpb $0x2a, %al
je 0x78f7e
incq %rbx
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x78f53
jmp 0x78f99
cmpb $0x2a, %al
jne 0x78fa7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x78f40
testb %al, %al
jne 0x78fab
cmpb $0x0, (%rbx)
leaq 0x1(%rbx), %rbx
jne 0x78f7e
movq %r14, %rbx
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x78f9f
movb $0x1, %al
jmp 0x78f9f
nop
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_1d_body()
TEST(shape_1d) {
  for (int stride : {1, 2, 10}) {
    dim<> x(0, 10, stride);
    shape<dim<>> s(x);
    for (int i : x) {
      ASSERT_EQ(s(i), i * stride);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, 0x2c(%rsp)
movl $0xa, 0x34(%rsp)
xorl %eax, %eax
leaq 0x38(%rsp), %r12
leaq 0x2407a(%rip), %rbx     # 0xa7256
movq %rax, 0x20(%rsp)
movslq 0x2c(%rsp,%rax), %r15
movl $0xa, %r13d
xorl %r14d, %r14d
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rsp, %rbp
movq %rbp, %rdi
leaq 0x3b73d(%rip), %rsi     # 0xbe942
leaq 0x3b748(%rip), %rdx     # 0xbe954
callq 0xd14c
movslq %r14d, %rax
xorl %esi, %esi
cmpq %rax, %r14
sete %sil
movq %r12, %rdi
movq %rbp, %rdx
callq 0xbf80
movq %r12, %rdi
leaq 0x20452(%rip), %rsi     # 0xa3684
callq 0x18fba
movq %rax, %rdi
leaq 0x2aff1(%rip), %rsi     # 0xae232
callq 0x18ff2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18fba
movq %rax, %rbp
cmpb $0x1, 0x188(%rax)
jne 0x8326c
movq %rbp, %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x21b0
movq %rbp, %rdi
leaq 0x2040e(%rip), %rsi     # 0xa3684
callq 0x18fba
movq %rax, %rdi
leaq 0x3b6c5(%rip), %rsi     # 0xbe94a
callq 0x19062
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18fba
movq %rax, %rbp
cmpb $0x1, 0x188(%rax)
jne 0x832b0
movq %rbp, %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x22f0
movq %rbp, %rdi
leaq 0x36fdf(%rip), %rsi     # 0xba299
callq 0x18fba
movq %r12, %rdi
callq 0xbfd8
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x832e2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
addq %r15, %r14
decq %r13
jne 0x831ef
movq 0x20(%rsp), %rax
addq $0x4, %rax
cmpq $0xc, %rax
jne 0x831dc
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8331c
movq %rax, %rbx
jmp 0x83329
jmp 0x8331c
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xbfd8
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x83344
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_1d_dense_body()
TEST(shape_1d_dense) {
  dense_dim<> x(0, 10);
  shape<dense_dim<>> s(x);
  for (int i : x) {
    ASSERT_EQ(s(i), i);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
leaq 0x28(%rsp), %rbx
movq $0x0, (%rbx)
movq $0xa, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
xorl %r14d, %r14d
xorl %edi, %edi
movq %rbx, %rsi
callq 0xd133
leaq 0x8(%rsp), %r13
leaq 0x202ea(%rip), %rbp     # 0xa3684
leaq 0x23eb5(%rip), %r12     # 0xa7256
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
leaq 0x3b5af(%rip), %rsi     # 0xbe964
leaq 0x3b5b1(%rip), %rdx     # 0xbe96d
callq 0xd14c
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0xbf80
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x18fba
movq %rax, %rdi
leaq 0x2ae4c(%rip), %rsi     # 0xae232
callq 0x18ff2
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fba
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x83411
movq %r15, %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x21b0
movq %r15, %rdi
movq %rbp, %rsi
callq 0x18fba
movq %rax, %rdi
leaq 0x36eb8(%rip), %rsi     # 0xba2de
callq 0x18fba
movq %rax, %rdi
movq %r12, %rsi
callq 0x18fba
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x83451
movq %r15, %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x22f0
movq %r15, %rdi
leaq 0x36e3e(%rip), %rsi     # 0xba299
callq 0x18fba
movq %rbx, %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x83484
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
incq %r14
cmpq $0xa, %r14
jne 0x833a1
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x834b7
jmp 0x834aa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x834d3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_2d_body()
TEST(shape_2d) {
  dense_dim<> x(0, 10);
  dim<> y(0, 5, x.extent());
  shape<dense_dim<>, dim<>> s(x, y);
  for (int i : y) {
    for (int j : x) {
      ASSERT_EQ(s(j, i), i * x.extent() + j);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
leaq 0x28(%rsp), %rbx
movq $0x0, (%rbx)
movq $0xa, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
xorl %r12d, %r12d
xorl %edi, %edi
movq %rbx, %rsi
callq 0xd133
leaq 0x18(%rsp), %r15
xorl %eax, %eax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x3b42f(%rip), %rsi     # 0xbe96e
leaq 0x3b445(%rip), %rdx     # 0xbe98b
callq 0xd14c
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xbf80
movq %rbx, %rdi
leaq 0x2011f(%rip), %rsi     # 0xa3684
callq 0x18fba
movq %rax, %rdi
leaq 0x3b418(%rip), %rsi     # 0xbe98c
callq 0x1909a
movq %rax, %rdi
leaq 0x23cd3(%rip), %rsi     # 0xa7256
callq 0x18fba
movq %rax, %rbp
movq %r15, %r14
leaq (%r12,%r13), %r15
cmpb $0x1, 0x188(%rax)
jne 0x835aa
movq %rbp, %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x21b0
movq %rbp, %rdi
leaq 0x200d0(%rip), %rsi     # 0xa3684
callq 0x18fba
movq %rax, %rdi
leaq 0x3b3b6(%rip), %rsi     # 0xbe979
callq 0x191ea
movq %rax, %rdi
leaq 0x23c84(%rip), %rsi     # 0xa7256
callq 0x18fba
movq %rax, %rbp
cmpb $0x1, 0x188(%rax)
jne 0x835f2
movq %rbp, %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x21b0
movq %rbp, %rdi
leaq 0x36c9d(%rip), %rsi     # 0xba299
callq 0x18fba
movq %rbx, %rdi
movq %r14, %r15
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x83623
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
incq %r13
cmpq $0xa, %r13
jne 0x8352b
movq (%rsp), %rax
incq %rax
addq $0xa, %r12
cmpq $0x5, %rax
jne 0x83524
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x83663
movq %rax, %rbx
jmp 0x83673
movq %rax, %rbx
jmp 0x83669
movq %rax, %rbx
movq %r14, %r15
leaq 0x28(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8368a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_clamp_body()
TEST(clamp) {
  dim<> x(5, 10, 1);
  for (int i = -10; i < 20; i++) {
    int correct = std::max(std::min(i, 14), 5);
    ASSERT_EQ(clamp(i, x), correct);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl $0xfffffff6, %r13d      # imm = 0xFFFFFFF6
leaq 0x28(%rsp), %r12
leaq 0x20fe8(%rip), %rbx     # 0xa7256
movl $0xe, %eax
cmpl %eax, %r13d
movl $0xe, %r14d
cmovll %r13d, %r14d
cmpl $0x6, %r14d
movl $0x5, %ecx
cmovll %ecx, %r14d
cmpl $0x6, %r13d
movl $0x5, %ebp
cmovgel %r13d, %ebp
cmpl $0xe, %ebp
cmovgel %eax, %ebp
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
leaq 0x38b9a(%rip), %rsi     # 0xbee53
leaq 0x38ba9(%rip), %rdx     # 0xbee69
callq 0xd14c
xorl %esi, %esi
cmpl %r14d, %ebp
sete %sil
movq %r12, %rdi
movq %r15, %rdx
callq 0xbf80
movq %r12, %rdi
leaq 0x1d3a1(%rip), %rsi     # 0xa3684
callq 0x18fba
movq %rax, %rdi
leaq 0x38b78(%rip), %rsi     # 0xbee6a
callq 0x57bb2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18fba
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x8631d
movq %r15, %rdi
addq $0x10, %rdi
movq %rbp, %rsi
callq 0x21b0
movq %r15, %rdi
leaq 0x1d35d(%rip), %rsi     # 0xa3684
callq 0x18fba
movq %rax, %rdi
leaq 0x38b2c(%rip), %rsi     # 0xbee62
callq 0x1909a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18fba
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x86361
movq %r15, %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x22f0
movq %r15, %rdi
leaq 0x33f2e(%rip), %rsi     # 0xba299
callq 0x18fba
movq %r12, %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x86394
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
incl %r13d
cmpl $0x14, %r13d
jne 0x8626e
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x863c7
jmp 0x863ba
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x863e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_all_indices_scalar_body()
TEST(for_all_indices_scalar) {
  shape<> s;
  int count = 0;
  move_only token;
  for_all_indices(s, [&, token = std::move(token)]() {
    count++;
    assert_used(token);
  });
  ASSERT_EQ(count, 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
leaq 0xc(%rsp), %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, 0x8(%rdi)
movl $0x1, (%rbx)
callq 0x203cc
movl (%rbx), %ebp
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x38a64(%rip), %rsi     # 0xbee8d
leaq 0x38a67(%rip), %rdx     # 0xbee97
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xd14c
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
leaq 0x30(%rsp), %rdi
movq %rbx, %rdx
callq 0xbf80
leaq 0x1d22a(%rip), %rsi     # 0xa3684
leaq 0x30(%rsp), %rdi
callq 0x18fba
leaq 0x29af7(%rip), %rsi     # 0xaff62
movq %rax, %rdi
callq 0x2d7d8
leaq 0x20ddc(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x8649e
movq %rbx, %rdi
addq $0x10, %rdi
movl 0xc(%rsp), %esi
callq 0x22f0
leaq 0x1d1df(%rip), %rsi     # 0xa3684
movq %rbx, %rdi
callq 0x18fba
leaq 0x242b8(%rip), %rsi     # 0xaa76c
movq %rax, %rdi
callq 0x18fba
leaq 0x20d93(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x864e8
movq %rbx, %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x22f0
leaq 0x33daa(%rip), %rsi     # 0xba299
movq %rbx, %rdi
callq 0x18fba
leaq 0x30(%rsp), %rdi
callq 0xbfd8
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x86518
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8652b
movq %rax, %rbx
jmp 0x86538
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbfd8
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x8654f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_each_index_scalar_body()
TEST(for_each_index_scalar) {
  shape<> s;
  int count = 0;
  move_only token;
  for_each_index(s, [&, token = std::move(token)](std::tuple<>) {
    count++;
    assert_used(token);
  });
  ASSERT_EQ(count, 1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
leaq 0xc(%rsp), %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, 0x8(%rdi)
movl $0x1, (%rbx)
callq 0x203cc
movl (%rbx), %ebp
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x374db(%rip), %rsi     # 0xbee8d
leaq 0x374de(%rip), %rdx     # 0xbee97
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xd14c
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
leaq 0x30(%rsp), %rdi
movq %rbx, %rdx
callq 0xbf80
leaq 0x1bca1(%rip), %rsi     # 0xa3684
leaq 0x30(%rsp), %rdi
callq 0x18fba
leaq 0x2856e(%rip), %rsi     # 0xaff62
movq %rax, %rdi
callq 0x2d7d8
leaq 0x1f853(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x87a27
movq %rbx, %rdi
addq $0x10, %rdi
movl 0xc(%rsp), %esi
callq 0x22f0
leaq 0x1bc56(%rip), %rsi     # 0xa3684
movq %rbx, %rdi
callq 0x18fba
leaq 0x22d2f(%rip), %rsi     # 0xaa76c
movq %rax, %rdi
callq 0x18fba
leaq 0x1f80a(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x87a71
movq %rbx, %rdi
addq $0x10, %rdi
movl $0x1, %esi
callq 0x22f0
leaq 0x32821(%rip), %rsi     # 0xba299
movq %rbx, %rdi
callq 0x18fba
leaq 0x30(%rsp), %rdi
callq 0xbfd8
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x87aa1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x87ab4
movq %rax, %rbx
jmp 0x87ac1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbfd8
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x87ad8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_dim_is_in_range_body()
TEST(dim_is_in_range) {
  dim<> x(2, 5);

  for (int i = 2; i < 7; i++) {
    ASSERT(x.is_in_range(i));
  }
  ASSERT(!x.is_in_range(1));
  ASSERT(!x.is_in_range(8));

  ASSERT(x.is_in_range(x));
  ASSERT(!x.is_in_range(interval<>(1, 2)));
  ASSERT(!x.is_in_range(interval<>(8, 2)));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x988, %rsp            # imm = 0x988
movl $0x5, %ebp
leaq 0x18(%rsp), %r13
leaq 0x360fe(%rip), %rbx     # 0xbefe8
leaq 0x36107(%rip), %r14     # 0xbeff8
leaq 0x8(%rsp), %r15
leaq 0x7f8(%rsp), %r12
movq %r13, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xd14c
movq %r12, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0xbf80
movq %r12, %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x88f40
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
decl %ebp
jne 0x88efe
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x360a6(%rip), %rsi     # 0xbeff9
leaq 0x360b0(%rip), %rdx     # 0xbf00a
callq 0xd14c
leaq 0x668(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x668(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x88f9a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x36062(%rip), %rsi     # 0xbf00b
leaq 0x3606c(%rip), %rdx     # 0xbf01c
callq 0xd14c
leaq 0x4d8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x4d8(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x88ff0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x3601e(%rip), %rsi     # 0xbf01d
leaq 0x36027(%rip), %rdx     # 0xbf02d
callq 0xd14c
leaq 0x348(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x348(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x89046
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x35fd9(%rip), %rsi     # 0xbf02e
leaq 0x35ff2(%rip), %rdx     # 0xbf04e
callq 0xd14c
leaq 0x1b8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x1b8(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8909c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x35fa4(%rip), %rsi     # 0xbf04f
leaq 0x35fbd(%rip), %rdx     # 0xbf06f
callq 0xd14c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x28(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x890ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
addq $0x988, %rsp            # imm = 0x988
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x89112
jmp 0x89112
jmp 0x89112
jmp 0x89112
jmp 0x89112
jmp 0x89117
jmp 0x89117
jmp 0x89117
jmp 0x89117
jmp 0x89117
movq %rax, %rbx
jmp 0x89131
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x89131
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_is_in_range_1d_body()
TEST(shape_is_in_range_1d) {
  dim<> x(2, 5);
  shape<dim<>> s(x);

  for (int i = 2; i < 7; i++) {
    ASSERT(s.is_in_range(i));
  }
  ASSERT(!s.is_in_range(1));
  ASSERT(!s.is_in_range(8));

  ASSERT(s.is_in_range(x));
  ASSERT(!s.is_in_range(interval<>(0, 2)));
  ASSERT(!s.is_in_range(interval<>(8, 12)));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x988, %rsp            # imm = 0x988
movl $0x5, %ebp
leaq 0x18(%rsp), %r13
leaq 0x35f2a(%rip), %rbx     # 0xbf085
leaq 0x35f33(%rip), %r14     # 0xbf095
leaq 0x8(%rsp), %r15
leaq 0x7f8(%rsp), %r12
movq %r13, 0x8(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xd14c
movq %r12, %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0xbf80
movq %r12, %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x891b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
decl %ebp
jne 0x8916f
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x35ed2(%rip), %rsi     # 0xbf096
leaq 0x35edc(%rip), %rdx     # 0xbf0a7
callq 0xd14c
leaq 0x668(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x668(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8920b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x35e8e(%rip), %rsi     # 0xbf0a8
leaq 0x35e98(%rip), %rdx     # 0xbf0b9
callq 0xd14c
leaq 0x4d8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x4d8(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x89261
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x35e4a(%rip), %rsi     # 0xbf0ba
leaq 0x35e53(%rip), %rdx     # 0xbf0ca
callq 0xd14c
leaq 0x348(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x348(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x892b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x35e05(%rip), %rsi     # 0xbf0cb
leaq 0x35e1e(%rip), %rdx     # 0xbf0eb
callq 0xd14c
leaq 0x1b8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x1b8(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8930d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x35dd0(%rip), %rsi     # 0xbf0ec
leaq 0x35dea(%rip), %rdx     # 0xbf10d
callq 0xd14c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x28(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8935d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
addq $0x988, %rsp            # imm = 0x988
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x89383
jmp 0x89383
jmp 0x89383
jmp 0x89383
jmp 0x89383
jmp 0x89388
jmp 0x89388
jmp 0x89388
jmp 0x89388
jmp 0x89388
movq %rax, %rbx
jmp 0x893a2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x893a2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/shape.cpp
// Function: nda::test_dim_conversion_body()
TEST(dim_conversion) {
  dense_dim<> x_dense(0, 10);
  dim<> x = x_dense;

  assert_dim_eq(x, dim<>(0, 10, 1));

  dim<> y(5, 15);
  dense_dim<> y_dense(y);
  assert_dim_eq(y_dense, dense_dim<>(5, 15));
  dense_dim<> y_dense2 = y;
  assert_dim_eq(y_dense2, dense_dim<>(5, 15));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
xorl %eax, %eax
leaq 0x48(%rsp), %rdi
movq %rax, (%rdi)
movl $0xa, %ecx
movq %rcx, 0x8(%rdi)
movl $0x1, %edx
movq %rdx, 0x10(%rdi)
leaq 0x18(%rsp), %rbx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rsi
callq 0x4ae75
movl $0x5, %r14d
movq %r14, (%rbx)
movl $0xf, %r15d
movq %r15, 0x8(%rbx)
movq %rsp, %rbx
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x4b40b
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
leaq 0x30(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, 0x8(%rsi)
movq %rsp, %rdi
callq 0x4b40b
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/split.cpp
// Function: nda::test_split_result_size_body()
TEST(split_result_size) {
  for (index_t extent = 1; extent < 100; ++extent) {
    interval<> v(0, extent);
    test_split_result_size(v, 1);
    test_split_result_size(v, 2);
    test_split_result_size(v, 3);
    test_split_result_size(v, 4);
    test_split_result_size(v, 5);
    test_split_result_size<1>(v);
    if (extent >= 2) test_split_result_size<2>(v);
    if (extent >= 3) test_split_result_size<3>(v);
    if (extent >= 4) test_split_result_size<4>(v);
    if (extent >= 5) test_split_result_size<5>(v);
  }
}

// Assembly:
pushq %rbx
movl $0x1, %ebx
movl $0x1, %edx
movq %rbx, %rsi
callq 0x9dff3
movl $0x2, %edx
movq %rbx, %rsi
callq 0x9dff3
movl $0x3, %edx
movq %rbx, %rsi
callq 0x9dff3
movl $0x4, %edx
movq %rbx, %rsi
callq 0x9dff3
movl $0x5, %edx
movq %rbx, %rsi
callq 0x9dff3
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9f48a
cmpq $0x2, %rbx
jb 0x9e22a
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9f5ff
cmpq $0x2, %rbx
je 0x9e22a
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9f797
cmpq $0x4, %rbx
jb 0x9e22a
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9f94e
cmpq $0x4, %rbx
je 0x9e22a
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9fae8
incq %rbx
cmpq $0x64, %rbx
jne 0x9e19f
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/test/test.h
// Function: std::ostream& nda::operator<<<-9l, -9l>(std::ostream&, nda::interval<-9l, -9l> const&)
std::ostream& operator<<(std::ostream& s, const interval<Min, Extent>& i) {
  s << "dim<";
  if (internal::is_static(Extent)) {
    ostream_comma_separated_list(s, Min, Extent);
  } else if (internal::is_static(Min)) {
    s << Min;
  }
  s << ">(";
  ostream_comma_separated_list(s, i.min(), i.extent());
  s << ")";
  return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7391(%rip), %rsi      # 0xa7359
movl $0x4, %edx
callq 0x2210
leaq 0x7385(%rip), %rsi      # 0xa735e
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2210
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1f3b8
leaq 0x4f27(%rip), %rsi      # 0xa4f23
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/include/array/array.h
// Function: nda::internal::split_iterator<-9l>::operator+=(long)
NDARRAY_HOST_DEVICE split_iterator& operator+=(index_t n) {
    assert(n >= 0);
    if (is_static(InnerExtent)) {
      // When the extent of the inner split is a compile-time constant,
      // we can't shrink the out of bounds interval. Instead, shift the min,
      // assuming the outer dimension is bigger than the inner extent.
      i.set_min(i.min() + InnerExtent * n);
      // Only shift the min when this straddles the end of the buffer,
      // so the iterator can advance to the end (one past the max).
      if (i.min() <= outer_max && i.max() > outer_max) { i.set_min(outer_max - InnerExtent + 1); }
    } else {
      // When the extent of the inner split is not a compile-time constant,
      // we can just modify the extent.
      i.set_min(i.min() + i.extent() * n);
      index_t max = min(i.max(), outer_max);
      i.set_extent(max - i.min() + 1);
    }
    return *this;
  }

// Assembly:
testq %rsi, %rsi
js 0xa21dc
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
imulq %rax, %rsi
addq (%rdi), %rsi
movq %rsi, (%rdi)
addq %rsi, %rax
decq %rax
cmpq %rax, %rcx
cmovlq %rcx, %rax
subq %rsi, %rax
incq %rax
movq %rax, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x1ead7(%rip), %rdi     # 0xc0cbb
leaq 0xf32(%rip), %rsi       # 0xa311d
leaq 0x1eb35(%rip), %rcx     # 0xc0d27
movl $0x21d, %edx            # imm = 0x21D
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/include/array/array.h
// Function: auto nda::internal::make_array_ref_at<int*, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::interval<-9l, 2l>, nda::interval<-9l, -9l>, nda::interval<-9l, 4l>>(int*, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>> const&, std::tuple<nda::interval<-9l, 2l>, nda::interval<-9l, -9l>, nda::interval<-9l, 4l>> const&)
NDARRAY_HOST_DEVICE auto make_array_ref_at(
    T base, const Shape& shape, const std::tuple<Args...>& args) {
  auto new_shape = shape[args];
  auto new_mins = mins_of_intervals(args, shape.dims(), make_index_sequence<sizeof...(Args)>());
  auto old_min_offset = shape[new_mins];
  return make_array_ref_no_resolve(internal::pointer_add(base, old_min_offset), new_shape);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rcx), %rax
movq 0x20(%rcx), %rcx
movq 0x10(%rdx), %rdx
movq 0x28(%r15), %rsi
movq %rsp, %r13
movq %rcx, 0x30(%r13)
movups 0x10(%r12), %xmm0
movups %xmm0, 0x18(%r13)
movq %rsi, 0x28(%r13)
movq %rax, (%r13)
movq %rdx, 0x10(%r13)
movq %r13, %rdi
callq 0xa22b8
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups 0x30(%r13), %xmm3
movups %xmm3, 0x38(%rbx)
movups %xmm2, 0x28(%rbx)
movups %xmm1, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
movq 0x20(%r12), %rax
movq (%r12), %rcx
movq 0x10(%r12), %rdx
subq 0x30(%r15), %rax
subq 0x18(%r15), %rdx
imulq 0x28(%r15), %rdx
subq (%r15), %rcx
imulq 0x10(%r15), %rcx
testq %r14, %r14
leaq (%r14,%rax,4), %rax
leaq (%rax,%rdx,4), %rax
leaq (%rax,%rcx,4), %rax
cmoveq %r14, %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/havannah/board.h
// Function: Morat::Havannah::Board::size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool size(std::string s) {
		if (!valid_size(s))
			return false;
		size_r_ = from_str<int>(s);
		size_r_m1_ = size_r_ - 1;
		size_ = size_r_ * 2 - 1;
		neighbor_list_ = gen_neighbor_list();
		num_cells_ = vec_size() - size_r_ * size_r_m1_;
		cells_.resize(vec_size());
		clear();
		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r14
callq 0xaf56
movl %eax, %ebp
addl $-0x3, %ebp
cmpl $0x7, %ebp
ja 0xaf47
movq %r14, %rdi
callq 0xaf56
movb %al, 0x1(%rbx)
leal -0x1(%rax), %ecx
addb %al, %al
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
decb %al
movb %cl, 0x2(%rbx)
movb %al, (%rbx)
callq 0x21318
vmovaps (%r14), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vmovaps %xmm1, (%r14)
movq 0x90(%rbx), %rdi
vmovups %xmm0, 0x88(%rbx)
testq %rdi, %rdi
je 0xaf1d
callq 0xb286
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xaf1d
callq 0xb286
movsbl (%rbx), %esi
movsbl 0x1(%rbx), %eax
movsbl 0x2(%rbx), %ecx
leaq 0x10(%rbx), %rdi
imull %esi, %esi
imull %eax, %ecx
movl %esi, %eax
subl %ecx, %eax
movw %ax, 0x4(%rbx)
callq 0xafd6
movq %rbx, %rdi
callq 0xb00a
cmpl $0x8, %ebp
setb %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/havannah/board.h
// Function: Morat::Havannah::Board::clear()
void clear() {
		last_move_ = M_NONE;
		num_moves_ = 0;
		to_play_ = Side::P1;
		outcome_ = Outcome::UNKNOWN;
		win_type_ = -1;
		check_rings = true;
		perm_rings = 0;
		hash.clear();

		for(int y = 0; y < size_; y++){
			for(int x = 0; x < size_; x++){
				MoveValid pos = move_valid(x, y);
				Side s = (on_board(x, y) ? Side::NONE : Side::UNDEF);
				cells_[pos.xy] = Cell(s, pos.xy, 1, (1 << iscorner(x, y)), (1 << isedge(x, y)), init_pattern(pos));
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x2e0e3(%rip), %rax     # 0x39102
movl $0x78fd0000, 0x6(%rdi)  # imm = 0x78FD0000
vxorps %xmm0, %xmm0, %xmm0
movb (%rax), %al
movb %al, 0xa(%rdi)
leaq 0x2e0d0(%rip), %rax     # 0x39106
movb (%rax), %al
movb %al, 0xb(%rdi)
movb $-0x1, 0xc(%rdi)
movb $0x1, 0x98(%rdi)
movl $0x0, 0x9c(%rdi)
vmovups %zmm0, 0x28(%rdi)
vmovups %zmm0, 0x48(%rdi)
movb (%rdi), %al
testb %al, %al
jle 0xb1de
movq %rdi, %rbx
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
testb %al, %al
jle 0xb1c3
movsbl %bpl, %ecx
movzbl %al, %r12d
xorl %r14d, %r14d
movl %ecx, 0x14(%rsp)
cmpl %r12d, %ebp
jge 0xb0c6
movsbl 0x1(%rbx), %eax
leaq 0x2e05d(%rip), %rcx     # 0x39100
movl %r14d, %edx
subl %ebp, %edx
cmpl %eax, %edx
jge 0xb0b3
leaq 0x2e04e(%rip), %rcx     # 0x39101
movl %ebp, %edx
subl %r14d, %edx
cmpl %eax, %edx
cmovgeq 0x40eee(%rip), %rcx     # 0x4bfb0
movb (%rcx), %al
jmp 0xb0cf
leaq 0x2e033(%rip), %rax     # 0x39100
movb (%rax), %al
movb %al, 0x7(%rsp)
movl %r12d, %eax
imull 0x14(%rsp), %eax
movsbl %r14b, %r13d
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
addl %eax, %r13d
vzeroupper
callq 0x21440
movl %eax, %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x214e6
imull 0x8(%rsp), %r12d
movl $0x3, %edi
xorl %edx, %edx
xorl %r8d, %r8d
addl %r14d, %r12d
movswq %r12w, %rcx
leaq (%rcx,%rcx,8), %rsi
movswq %r13w, %rcx
shlq $0x3, %rsi
addq 0x88(%rbx), %rsi
cmpl $0xffff0000, (%rsi,%r8) # imm = 0xFFFF0000
movl $0x0, %r9d
cmovaeq %rdi, %r9
shlq $0x2, %rdi
addq $0x4, %r8
orq %r9, %rdx
cmpq $0x48, %r8
jne 0xb12c
movq 0x10(%rbx), %r10
movb 0x7(%rsp), %r9b
movl $0x3f03f03f, %r8d       # imm = 0x3F03F03F
movq %rdx, %r11
shrq $0x6, %rdx
movl $0x1, %edi
incl %r14d
andq %r8, %r11
andq %r8, %rdx
movq %rcx, %r8
shlq $0x4, %r8
shlxl %r15d, %edi, %esi
shlxl %eax, %edi, %eax
shlq $0x6, %r11
orq %r11, %rdx
movb %r9b, (%r10,%r8)
movb $0x1, 0x1(%r10,%r8)
movw %cx, 0x2(%r10,%r8)
movb %sil, 0x4(%r10,%r8)
movb %al, 0x5(%r10,%r8)
movw $0x0, 0x6(%r10,%r8)
movq %rdx, 0x8(%r10,%r8)
movb (%rbx), %al
movsbl %al, %r12d
cmpl %r12d, %r14d
jl 0xb093
jmp 0xb1c7
movsbl %al, %r12d
movq 0x8(%rsp), %rcx
incl %ebp
incl %ecx
movq %rcx, 0x8(%rsp)
cmpl %r12d, %ebp
jl 0xb07c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/havannah/lbdist.h
// Function: Morat::Havannah::LBDists::isdraw()
Outcome isdraw() {
		Outcome outcome = Outcome::DRAW;  // assume neither side can win
		for(int y = 0; y < board->lines(); y++) {
			for(int x = board->line_start(y); x < board->line_end(y); x++) {
				MoveValid pos(x, y, board->xy(x, y));

				if(board->encirclable(pos, Side::P1) || get(pos.xy, Side::P1) < maxdist-5)
					outcome |= Outcome::P1; // P1 can win
				if(board->encirclable(pos, Side::P2) || get(pos.xy, Side::P2) < maxdist-5)
					outcome |= Outcome::P2; // P2 can win

				if(outcome == Outcome::DRAW2) // both can win
					return Outcome::UNKNOWN;  // so nothing is known
			}
		}
		return -outcome; // this isn't certainty, so negate
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x21078(%rip), %rax     # 0x39109
movq 0xcb28(%rdi), %rdi
movb (%rax), %bl
cmpb $0x0, (%rdi)
jle 0x181ab
movb 0x1(%rdi), %al
xorl %ecx, %ecx
xorl %r12d, %r12d
movsbl %al, %eax
movl $0x0, %r13d
cmpl %eax, %r12d
jl 0x180c3
movsbl 0x2(%rdi), %eax
movl %r12d, %r13d
subl %eax, %r13d
movl %r13d, %ebp
shll $0x8, %ebp
movl %ecx, 0x4(%rsp)
addl %ecx, %ebp
movq 0xcb28(%r14), %rdi
movb 0x1(%rdi), %al
movsbl %al, %ecx
cmpl %ecx, %r12d
jge 0x180e6
addl %r12d, %ecx
jmp 0x180e9
movsbl (%rdi), %ecx
cmpl %ecx, %r13d
jge 0x18194
leaq 0x21009(%rip), %rax     # 0x39102
movsbl (%rdi), %r15d
movl %ebp, %esi
movzbl (%rax), %edx
imull %r12d, %r15d
addl %r13d, %r15d
callq 0x18a82
testb %al, %al
jne 0x1812f
leaq 0x20fe9(%rip), %rax     # 0x39102
movswl %r15w, %esi
movq %r14, %rdi
movzbl (%rax), %edx
callq 0x18b84
cmpl $0x3e2, %eax            # imm = 0x3E2
jg 0x18138
leaq 0x20fd4(%rip), %rax     # 0x3910a
orb (%rax), %bl
leaq 0x20fc4(%rip), %rax     # 0x39103
movq 0xcb28(%r14), %rdi
movl %ebp, %esi
movzbl (%rax), %edx
callq 0x18a82
testb %al, %al
jne 0x18171
leaq 0x20fa8(%rip), %rax     # 0x39103
movswl %r15w, %esi
movq %r14, %rdi
movzbl (%rax), %edx
callq 0x18b84
cmpl $0x3e2, %eax            # imm = 0x3E2
jg 0x1817a
leaq 0x20f93(%rip), %rax     # 0x3910b
orb (%rax), %bl
leaq 0x20f8b(%rip), %rax     # 0x3910c
incl %r13d
addl $0x100, %ebp            # imm = 0x100
cmpb (%rax), %bl
jne 0x180cf
jmp 0x181b0
movl 0x4(%rsp), %edx
movsbl (%rdi), %ecx
incl %r12d
incl %edx
cmpl %ecx, %r12d
movl %edx, %ecx
jl 0x180ab
addb $-0x3, %bl
jmp 0x181b9
leaq 0x20f4f(%rip), %rax     # 0x39106
movb (%rax), %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/havannah/board.h
// Function: Morat::Havannah::Board::test_outcome(Morat::MoveValid const&, Morat::Side) const
Outcome test_outcome(const MoveValid & pos, Side turn) const {
		if(test_local(pos, turn)){
			Cell testcell = cells_[find_group(pos.xy)];
			int numgroups = 0;
			auto it = neighbors_small(pos);
			for (const MoveValid *i = it.begin(), *e = it.end(); i < e; i++) {
				if(i->on_board() && turn == get(i->xy)){
					const Cell * g = & cells_[find_group(i->xy)];
					testcell.corner |= g->corner;
					testcell.edge   |= g->edge;
					testcell.size   += g->size;
					i++; //skip the next one
					numgroups++;
				}
			}

			if(testcell.numcorners() >= 2 || testcell.numedges() >= 3 || (check_rings && numgroups >= 2 && testcell.size >= 6 && checkring_o1(pos, turn)))
				return +turn;
		}

		if(num_moves_+1 == num_cells_)
			return Outcome::DRAW;

		return Outcome::UNKNOWN;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movswl 0x2(%rsi), %esi
movl %edx, %ebx
movq %rdi, %r14
callq 0x18ce8
cmpl $0x3, %eax
jne 0x18314
movswl 0x2(%r15), %esi
movq 0x10(%r14), %rax
movq %rsi, %rdi
shlq $0x4, %rdi
movslq %esi, %rdx
movzwl 0x2(%rax,%rdi), %ecx
cmpl %edx, %ecx
je 0x1822d
leaq 0x2(%rax,%rdi), %rsi
movl %ecx, %ecx
shlq $0x4, %rcx
movzwl 0x2(%rax,%rcx), %edi
movzwl %di, %ecx
movl %ecx, %r8d
shll $0x4, %r8d
cmpw 0x2(%rax,%r8), %di
jne 0x1820a
movw %cx, (%rsi)
movq %rcx, %rsi
shlq $0x4, %rsi
leaq (%rdx,%rdx,8), %rdx
xorl %edi, %edi
vmovd 0x4(%rax,%rsi), %xmm0
movb 0x1(%rax,%rsi), %cl
movq 0x88(%r14), %rsi
leaq 0x2(%rsi,%rdx,8), %rsi
xorl %edx, %edx
movswq (%rsi,%rdi), %r10
cmpq $-0x1, %r10
je 0x182c2
movq %r10, %r8
shlq $0x4, %r8
cmpb %bl, (%rax,%r8)
jne 0x182c2
movl %r10d, %r9d
movq %r9, %r11
shlq $0x4, %r11
movzwl 0x2(%rax,%r11), %r8d
cmpl %r10d, %r8d
je 0x182a8
leaq 0x2(%rax,%r11), %r9
movl %r8d, %r8d
shlq $0x4, %r8
movzwl 0x2(%rax,%r8), %r10d
movzwl %r10w, %r8d
movl %r8d, %r11d
shll $0x4, %r11d
cmpw 0x2(%rax,%r11), %r10w
jne 0x18281
movw %r8w, (%r9)
movq %r8, %r9
shlq $0x4, %r9
addq $0x4, %rdi
incl %edx
vmovd 0x4(%rax,%r9), %xmm1
addb 0x1(%rax,%r9), %cl
vpor %xmm0, %xmm1, %xmm0
leaq 0x4(%rdi), %r8
cmpq $0x14, %rdi
movq %r8, %rdi
jl 0x1824f
vpextrb $0x0, %xmm0, %esi
leaq 0x1d794(%rip), %rax     # 0x35a70
cmpb $0x1, (%rsi,%rax)
ja 0x18336
vpextrb $0x1, %xmm0, %esi
cmpb $0x2, (%rsi,%rax)
ja 0x18336
cmpb $0x1, 0x98(%r14)
jne 0x18314
cmpl $0x2, %edx
jl 0x18314
cmpb $0x6, %cl
jb 0x18314
movzbl %bl, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x217f8
testb %al, %al
jne 0x18336
movswl 0x6(%r14), %eax
movswl 0x4(%r14), %ecx
incl %eax
cmpl %ecx, %eax
jne 0x1832d
leaq 0x20dde(%rip), %rax     # 0x39109
jmp 0x18334
leaq 0x20dd2(%rip), %rax     # 0x39106
movb (%rax), %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq