LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/include/array/image.h
// Function: nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>> nda::crop<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>>(nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>> 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
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq 0x20(%rsi), %rdx
movq 0x38(%rsi), %rax
cmpq %r15, %rax
cmovgq %rax, %r15
cmpq %rcx, %rdx
cmovgq %rdx, %r14
movq 0x40(%rsi), %rcx
addq %rax, %rcx
cmpq %r8, %rcx
cmovgeq %r8, %rcx
movl 0x80(%rsp), %ebp
movq 0x28(%rsi), %rdi
addq %rdx, %rdi
cmpq %r9, %rdi
cmovgeq %r9, %rdi
leaq 0x8(%rsi), %r10
movq 0x30(%rsi), %r9
movq 0x48(%rsi), %r8
subq %r15, %rcx
subq %r14, %rdi
testl %ebp, %ebp
je 0x51626
cmpl $0x1, %ebp
jne 0x5162a
movq %r15, %rax
movq %r14, %rdx
jmp 0x5162a
xorl %eax, %eax
xorl %edx, %edx
movq 0x10(%r10), %r11
movq %r11, 0x10(%rsp)
movups (%r10), %xmm0
movaps %xmm0, (%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %r9, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq 0x8(%rsi), %r13
cmpq $0x0, (%rsi)
je 0x51679
movq %rsi, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x51a48
movq %rax, %r12
jmp 0x5167c
xorl %r12d, %r12d
cmpl $0x1, %ebp
jne 0x516a3
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x51a5c
shlq $0x2, %rax
movq %r12, %rcx
subq %rax, %rcx
testq %r12, %r12
cmovneq %rcx, %r12
movq %r12, (%rbx)
movq %rbx, %rax
addq $0x8, %rax
pushq $0x9
popq %rcx
movq %rsp, %rsi
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x6e6d
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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::transform_index<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>, void nda::fill_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&, int)::'lambda'(std::tuple<long, long, long> const&)>(nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>> const&, void nda::fill_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&, int)::'lambda'(std::tuple<long, long, long> 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 %rsi, %rbx
movq 0x8(%rdi), %r12
movq %rdi, (%rsp)
movq 0x10(%rdi), %rax
addq %r12, %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %r15
cmpq 0x8(%rsp), %r12
je 0x51f5b
movq (%rsp), %rax
movq 0x20(%rax), %rbp
movq 0x28(%rax), %r13
addq %rbp, %r13
cmpq %r13, %rbp
je 0x51f56
xorl %r14d, %r14d
cmpq $0x3, %r14
je 0x51f51
movq %r14, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %rbp, 0x20(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51f6a
incq %r14
jmp 0x51f2c
incq %rbp
jmp 0x51f24
incq %r12
jmp 0x51f0e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/include/array/image.h
// Function: void nda::shape_traits<nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, -9l, 1l>>>::for_each_value<int*, nda::array<int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, -9l, 1l>>, std::allocator<int>>::construct()::'lambda'(int&)&>(nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, -9l, 1l>> const&, int*, nda::array<int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, -9l, 1l>>, std::allocator<int>>::construct()::'lambda'(int&)&)
static void for_each_value(const shape_type& s, Ptr base, Fn&& fn) {
    const index_t channels = s.c().extent();
    if (channels == s.x().stride()) {
      dense_shape<2> opt_s({s.x().min() * channels, s.x().extent() * channels}, s.y());
      for_each_value_in_order(opt_s, base, fn);
    } else {
      for_each_value_in_order(s, base, fn);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %rdx
movq 0x8(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rcx, %rax
jne 0x64d62
movq 0x30(%rdx), %rcx
imulq %rax, %rcx
imulq 0x38(%rdx), %rax
leaq 0x30(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
addq $0x18, %rdx
movq %rsp, %rdi
callq 0x1091e
testq %rbx, %rbx
je 0x64df9
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
xorl %esi, %esi
testq %rax, %rax
cmovleq %rsi, %rax
cmpq %rax, %rsi
je 0x64e2f
leaq (%rbx,%rdx,4), %rdi
movq %rbx, %r8
cmpq %rdi, %r8
jae 0x64d59
andl $0x0, (%r8)
addq $0x4, %r8
jmp 0x64d4a
leaq (%rbx,%rcx,4), %rbx
incq %rsi
jmp 0x64d3a
testq %rbx, %rbx
je 0x64e20
movq 0x20(%rdx), %rsi
movq 0x28(%rdx), %rdi
movq 0x38(%rdx), %rdx
xorl %r8d, %r8d
testq %rsi, %rsi
cmovleq %r8, %rsi
testq %rax, %rax
cmovleq %r8, %rax
testq %rdx, %rdx
movl $0x0, %r9d
cmovgq %rdx, %r9
shlq $0x2, %rdi
leaq (,%rcx,4), %r10
cmpq %rax, %r8
je 0x64e2f
movq %rbx, %r11
xorl %r14d, %r14d
cmpq %rsi, %r14
je 0x64df0
movq %r9, %r15
movq %r11, %r12
cmpq $0x1, %rcx
jne 0x64dd8
leaq (%r11,%rdx,4), %r15
movq %r11, %r12
cmpq %r15, %r12
jae 0x64de8
andl $0x0, (%r12)
addq $0x4, %r12
jmp 0x64dc8
subq $0x1, %r15
jb 0x64de8
andl $0x0, (%r12)
addq %r10, %r12
jmp 0x64dd8
addq %rdi, %r11
incq %r14
jmp 0x64db0
addq $0x4, %rbx
incq %r8
jmp 0x64da1
movq 0x8(%rsp), %rax
imulq 0x20(%rsp), %rax
testq %rax, %rax
jle 0x64e2f
leaq 0x2847f(%rip), %rdi     # 0x8d28f
leaq 0x282ba(%rip), %rsi     # 0x8d0d1
leaq 0x3a598(%rip), %rcx     # 0x9f3b6
jmp 0x64e50
imulq 0x38(%rdx), %rax
imulq 0x20(%rdx), %rax
testq %rax, %rax
jg 0x64e3b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2844d(%rip), %rdi     # 0x8d28f
leaq 0x28288(%rip), %rsi     # 0x8d0d1
leaq 0x3fcf6(%rip), %rcx     # 0xa4b46
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/test/main.cpp
// Function: main
int main(int argc, const char** argv) {
  // By default, the filter matches all tests.
  const char* filter = "*";
  if (argc > 1) {
    filter = argv[1];
    std::cout << "Running tests matching '" << filter << "'..." << std::endl;
  }

  size_t passed = 0;
  size_t total = 0;
  for (auto& i : tests()) {
    if (!wildcard_match(filter, i.first.c_str())) continue;

    std::cout << i.first << " ";
    std::flush(std::cout);
    try {
      i.second();
      std::cout << "passed" << std::endl;
      passed++;
    } catch (const std::exception& e) { std::cout << "failed: " << e.what() << std::endl; }
    total++;
  }
  std::cout << passed << " of " << total << " tests passed, " << tests().size() - total
            << " skipped" << std::endl;
  return passed < total ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, %edi
jl 0x657b9
movq 0x8(%rsi), %r15
movq 0x7c83f(%rip), %rdi     # 0xe1fc8
leaq 0x3fad1(%rip), %rsi     # 0xa5261
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
leaq 0x3fad3(%rip), %rsi     # 0xa527a
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20a0
jmp 0x657c0
leaq 0x3fa9f(%rip), %r15     # 0xa525f
callq 0x65715
movq 0x7cb24(%rip), %r12     # 0xe22f0
xorl %ebx, %ebx
movq 0x7cb23(%rip), %rbp     # 0xe22f8
movq 0x7c7ec(%rip), %r13     # 0xe1fc8
xorl %r14d, %r14d
cmpq %rbp, %r12
je 0x6589f
movq (%r12), %rsi
movq %r15, %rdi
callq 0x65945
testb %al, %al
je 0x65841
movq %r13, %rdi
movq %r12, %rsi
callq 0x2190
movq %rax, %rdi
leaq 0x3fa95(%rip), %rsi     # 0xa52a2
callq 0x21c0
movq %r13, %rdi
callq 0x2100
leaq 0x20(%r12), %rdi
callq 0x65a08
movq %r13, %rdi
leaq 0x3fa51(%rip), %rsi     # 0xa527f
callq 0x21c0
movq %rax, %rdi
callq 0x20a0
incq %r14
incq %rbx
addq $0x40, %r12
jmp 0x657df
movq %rax, 0x8(%rsp)
cmpl $0x1, %edx
jne 0x65933
movq 0x8(%rsp), %rdi
callq 0x2060
movq %rax, 0x8(%rsp)
movq %r13, %rdi
leaq 0x3fa18(%rip), %rsi     # 0xa5286
callq 0x21c0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20a0
callq 0x22b0
jmp 0x6583e
movq 0x7c722(%rip), %rdi     # 0xe1fc8
movq %r14, %rsi
callq 0x20f0
leaq 0x3f9da(%rip), %rsi     # 0xa528f
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20f0
leaq 0x3f9c5(%rip), %rsi     # 0xa5294
movq %rax, %rdi
callq 0x21c0
movq %rax, %r15
callq 0x65715
movq 0x7ca12(%rip), %rsi     # 0xe22f8
subq 0x7ca03(%rip), %rsi     # 0xe22f0
sarq $0x6, %rsi
subq %rbx, %rsi
movq %r15, %rdi
callq 0x20f0
leaq 0x3f9a1(%rip), %rsi     # 0xa52a4
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20a0
xorl %eax, %eax
cmpq %rbx, %r14
sbbl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
callq 0x22b0
movq 0x8(%rsp), %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %r14
incq %r14
movb -0x1(%r14), %al
testb %al, %al
je 0x65996
movb (%rbx), %cl
testb %cl, %cl
je 0x65977
cmpb %cl, %al
setne %cl
cmpb $0x3f, %al
setne %dl
testb %cl, %dl
jne 0x65977
cmpb $0x2a, %al
je 0x6597b
incq %rbx
jmp 0x6594f
cmpb $0x2a, %al
jne 0x6599e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65945
testb %al, %al
jne 0x659a2
cmpb $0x0, (%rbx)
leaq 0x1(%rbx), %rbx
jne 0x6597b
movq %r14, %rbx
cmpb $0x0, (%rbx)
sete %al
jmp 0x659a4
xorl %eax, %eax
jmp 0x659a4
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/test/matrix.cpp
// Function: nda::test_matrix_transpose_body()
TEST(matrix_transpose) {
  matrix<int> m({5, 8});
  fill_pattern(m);
  auto mt = transpose<1, 0>(m);
  for_all_indices(m.shape(), [&](int i, int j) { ASSERT_EQ(m(i, j), mt(j, i)); });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
leaq 0xd8(%rsp), %rbx
pushq $0x5
popq %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x66cac
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10998
movq %r14, %rdi
xorl %esi, %esi
callq 0x66d84
leaq 0x80(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x66db7
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rcx
addq %rax, %rcx
movq %rcx, 0x10(%rsp)
leaq 0xd8(%rsp), %rbx
leaq 0x274e1(%rip), %rbp     # 0x8d647
cmpq 0x10(%rsp), %rax
je 0x6632b
movq 0x50(%rsp), %r15
movq 0x58(%rsp), %rcx
movq %rax, 0x18(%rsp)
cltq
movq %rax, 0x8(%rsp)
shlq $0x20, %r15
subq $0x1, %rcx
jb 0x6631e
movq %rcx, 0x20(%rsp)
movq %rbx, %r13
movq 0x8(%rsp), %rdx
movq %rdx, %rax
subq 0x68(%rsp), %rax
imulq 0x78(%rsp), %rax
movq %r15, 0x28(%rsp)
sarq $0x20, %r15
movq %r15, %rcx
subq 0x50(%rsp), %rcx
shlq $0x2, %rcx
addq 0x48(%rsp), %rcx
movl (%rcx,%rax,4), %ebx
movq %r15, %rax
subq 0xa0(%rsp), %rax
movq %rdx, %rcx
subq 0x88(%rsp), %rcx
imulq 0x98(%rsp), %rcx
shlq $0x2, %rax
addq 0x80(%rsp), %rax
movl (%rax,%rcx,4), %r12d
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
leaq 0x3f4f9(%rip), %rsi     # 0xa5707
leaq 0x7(%rsp), %rdx
callq 0x66a0
xorl %esi, %esi
cmpl %r12d, %ebx
sete %sil
movq %r13, %rbx
movq %r13, %rdi
movq %r14, %rdx
callq 0x6894
leaq 0x2b3bc(%rip), %r13     # 0x915f2
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x3f4d0(%rip), %rsi     # 0xa571b
callq 0x107f4
movq %rax, %rdi
movq %r13, %rsi
callq 0x106fe
movq 0x8(%rsp), %rcx
subq 0x68(%rsp), %rcx
imulq 0x78(%rsp), %rcx
movq %r15, %rdx
subq 0x50(%rsp), %rdx
shlq $0x2, %rdx
addq 0x48(%rsp), %rdx
leaq (%rdx,%rcx,4), %rsi
movq %rax, %rdi
callq 0x10736
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x3f475(%rip), %rsi     # 0xa5712
callq 0x118ac
movq %rax, %rdi
movq %r13, %rsi
callq 0x106fe
subq 0xa0(%rsp), %r15
movq 0x8(%rsp), %rcx
subq 0x88(%rsp), %rcx
imulq 0x98(%rsp), %rcx
shlq $0x2, %r15
addq 0x80(%rsp), %r15
leaq (%r15,%rcx,4), %rsi
movq %rax, %rdi
callq 0x10736
movq %rax, %rdi
leaq 0x3efb5(%rip), %rsi     # 0xa52a2
callq 0x106fe
movq %rbx, %rdi
callq 0x68d4
movq %r14, %rdi
callq 0x2090
movabsq $0x100000000, %rax      # imm = 0x100000000
movq 0x28(%rsp), %r15
addq %rax, %r15
movq 0x20(%rsp), %rcx
jmp 0x6618b
movq 0x18(%rsp), %rax
incq %rax
jmp 0x66166
leaq 0x30(%rsp), %rdi
callq 0x10a06
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6634b
jmp 0x6634b
movq %rax, %rbx
jmp 0x66372
movq %rax, %rbx
jmp 0x66365
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x68d4
leaq 0xb8(%rsp), %rdi
callq 0x2090
leaq 0x30(%rsp), %rdi
callq 0x10a06
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6d740
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 0x3ad5d(%rip), %rdi     # 0xa84a5
leaq 0x1f982(%rip), %rsi     # 0x8d0d1
leaq 0x3ad56(%rip), %rcx     # 0xa84ac
movl $0x21d, %edx            # imm = 0x21D
callq 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1d8, %rsp            # imm = 0x1D8
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, 0x1c(%rsp)
movl $0xa, 0x24(%rsp)
xorl %eax, %eax
leaq 0x28(%rsp), %r14
leaq 0x48(%rsp), %r12
leaq 0x21bf0(%rip), %rbx     # 0x915f2
cmpq $0xc, %rax
je 0x6fafc
movq %rax, 0x8(%rsp)
movslq 0x1c(%rsp,%rax), %r15
pushq $0xa
popq %rbp
xorl %r13d, %r13d
subq $0x1, %rbp
jb 0x6faee
movq %r14, %rdi
leaq 0x3a63d(%rip), %rsi     # 0xaa06d
leaq 0x3(%rsp), %rdx
callq 0x66a0
movslq %r13d, %rax
xorl %esi, %esi
cmpq %rax, %r13
sete %sil
movq %r12, %rdi
movq %r14, %rdx
callq 0x6894
movq %r12, %rdi
leaq 0x1dbec(%rip), %rsi     # 0x8d647
callq 0x106fe
movq %rax, %rdi
leaq 0x28d38(%rip), %rsi     # 0x987a2
callq 0x1071a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x106fe
movq %r13, 0x10(%rsp)
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x107ba
movq %rax, %rdi
leaq 0x1dbb1(%rip), %rsi     # 0x8d647
callq 0x106fe
movq %rax, %rdi
leaq 0x3a5d0(%rip), %rsi     # 0xaa075
callq 0x107d8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x106fe
movl %r13d, 0x4(%rsp)
movq %rax, %rdi
leaq 0x4(%rsp), %rsi
callq 0x10736
movq %rax, %rdi
leaq 0x357d1(%rip), %rsi     # 0xa52a2
callq 0x106fe
movq %r12, %rdi
callq 0x68d4
movq %r14, %rdi
callq 0x2090
addq %r15, %r13
jmp 0x6fa1c
movq 0x8(%rsp), %rax
addq $0x4, %rax
jmp 0x6fa02
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6fb17
movq %rax, %rbx
jmp 0x6fb24
jmp 0x6fb17
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x68d4
leaq 0x28(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1f8, %rsp            # imm = 0x1F8
leaq 0x50(%rsp), %rbx
andq $0x0, (%rbx)
movq $0xa, 0x8(%rbx)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x3c10a
movl (%rbx), %eax
movq 0x8(%rbx), %r13
leaq 0x68(%rsp), %r14
leaq 0x1dac8(%rip), %r15     # 0x8d647
leaq 0x21a6c(%rip), %rbp     # 0x915f2
subq $0x1, %r13
jb 0x6fc71
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq %r15, %rbx
xorl %r15d, %r15d
cmpq $0x0, 0x18(%rsp)
sete %r15b
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0x3a4d8(%rip), %rsi     # 0xaa08f
leaq 0x7(%rsp), %rdx
callq 0x66a0
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %r15
movq %r12, %rdx
callq 0x6894
movq %r14, %rdi
movq %r15, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x28bbb(%rip), %rsi     # 0x987a2
callq 0x1071a
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movslq 0x8(%rsp), %rcx
subq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x107ba
movq %rax, %rdi
movq %r15, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x356bf(%rip), %rsi     # 0xa52e7
callq 0x106fe
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x10736
movq %rax, %rdi
leaq 0x35653(%rip), %rsi     # 0xa52a2
callq 0x106fe
movq %r14, %rdi
callq 0x68d4
leaq 0x30(%rsp), %rdi
callq 0x2090
movl 0xc(%rsp), %eax
incl %eax
jmp 0x6fb86
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6fc97
jmp 0x6fc8a
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x68d4
leaq 0x30(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x258, %rsp            # imm = 0x258
leaq 0x48(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0xb0(%rsp), %rbx
andq $0x0, (%rbx)
pushq $0xa
popq %rax
movq %rax, 0x8(%rsi)
movq $0x5, 0x8(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x60(%rsp), %rdi
movq %rbx, %rdx
callq 0x1091e
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq %rax, %rcx
movq %rcx, 0x18(%rsp)
leaq 0xc8(%rsp), %r12
leaq 0x218dd(%rip), %rbp     # 0x915f2
cmpq 0x18(%rsp), %rax
je 0x6fe9d
movq 0x48(%rsp), %r15
movq 0x50(%rsp), %rcx
movq %rax, 0x20(%rsp)
cltq
movq %rax, 0x10(%rsp)
shlq $0x20, %r15
subq $0x1, %rcx
jb 0x6fe90
movq %rcx, 0x28(%rsp)
movq %r15, 0x30(%rsp)
sarq $0x20, %r15
movq %r15, %rax
subq 0x78(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %r13
subq 0x60(%rsp), %r13
imulq 0x70(%rsp), %r13
addq %rax, %r13
movq %r12, %r14
movq 0x50(%rsp), %r12
imulq %rcx, %r12
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
leaq 0x3a30b(%rip), %rsi     # 0xaa099
leaq 0xf(%rsp), %rdx
callq 0x66a0
addq %r15, %r12
xorl %esi, %esi
cmpq %r12, %r13
movq %r14, %r12
sete %sil
movq %r14, %rdi
movq %rbx, %rdx
leaq 0x1d893(%rip), %rbx     # 0x8d647
callq 0x6894
movq %r12, %rdi
movq %rbx, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x3a2e9(%rip), %rsi     # 0xaa0b7
callq 0x107f4
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movq %r15, %rcx
subq 0x78(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq 0x60(%rsp), %rdx
imulq 0x70(%rsp), %rdx
addq %rcx, %rdx
movq %rdx, 0x40(%rsp)
movq %rax, %rdi
leaq 0x40(%rsp), %rsi
callq 0x107ba
movq %rax, %rdi
movq %rbx, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x3a284(%rip), %rsi     # 0xaa0a4
callq 0x109ce
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movq 0x50(%rsp), %rcx
imulq 0x10(%rsp), %rcx
addq %r15, %rcx
movq %rcx, 0x38(%rsp)
movq %rax, %rdi
leaq 0x38(%rsp), %rsi
callq 0x107ba
movq %rax, %rdi
leaq 0x35448(%rip), %rsi     # 0xa52a2
callq 0x106fe
movq %r12, %rdi
callq 0x68d4
leaq 0x90(%rsp), %rdi
callq 0x2090
movabsq $0x100000000, %rax      # imm = 0x100000000
movq 0x30(%rsp), %r15
addq %rax, %r15
movq 0x28(%rsp), %rcx
jmp 0x6fd3a
movq 0x20(%rsp), %rax
incq %rax
jmp 0x6fd15
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6feb8
movq %rax, %rbx
jmp 0x6fec8
jmp 0x6feb8
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x68d4
leaq 0x90(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/test/shape.cpp
// Function: nda::test_broadcast_dim_body()
TEST(broadcast_dim) {
  dim<> x(0, 10, 1);
  broadcast_dim<> y;
  shape<dim<>, broadcast_dim<>> s(x, y);
  for (int i = 0; i < 10; i++) {
    for (int j : x) {
      ASSERT_EQ(s(j, i), j);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
movq $0xa, 0x8(%rsi)
movq $0x1, 0x10(%rsi)
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x50(%rsp), %rdi
callq 0x77154
xorl %eax, %eax
leaq 0xb8(%rsp), %r15
leaq 0x1b198(%rip), %r14     # 0x8d647
leaq 0x1f13c(%rip), %rbp     # 0x915f2
cmpl $0xa, %eax
je 0x7260a
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rax, %r13
shlq $0x20, %r13
subq $0x1, %rcx
jb 0x725ff
movq %rcx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl %eax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
sarq $0x20, %r13
movq %r14, %rbx
movq %r15, %r14
movq %r13, %r15
subq 0x68(%rsp), %r15
imulq 0x78(%rsp), %r15
leaq 0x80(%rsp), %r12
movq %r12, %rdi
leaq 0x38050(%rip), %rsi     # 0xaa56b
leaq 0xf(%rsp), %rdx
callq 0x66a0
xorl %esi, %esi
cmpq %r13, %r15
movq %r14, %r15
movq %rbx, %r14
sete %sil
movq %r15, %rdi
movq %r12, %rdx
callq 0x6894
movq %r15, %rdi
movq %r14, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x37b63(%rip), %rsi     # 0xaa0b7
callq 0x107f4
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movslq 0x10(%rsp), %rcx
subq 0x68(%rsp), %rcx
imulq 0x78(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x107ba
movq %rax, %rdi
movq %r14, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x37b1a(%rip), %rsi     # 0xaa0b5
callq 0x106fe
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x10736
movq %rax, %rdi
leaq 0x32ce0(%rip), %rsi     # 0xa52a2
callq 0x106fe
movq %r15, %rdi
callq 0x68d4
leaq 0x80(%rsp), %rdi
callq 0x2090
movabsq $0x100000000, %rax      # imm = 0x100000000
movq 0x18(%rsp), %r13
addq %rax, %r13
movq 0x28(%rsp), %rax
incl %eax
movq 0x20(%rsp), %rcx
jmp 0x724d4
movl 0x14(%rsp), %eax
incl %eax
jmp 0x724b6
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x72633
jmp 0x72623
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x68d4
leaq 0x80(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1c8, %rsp            # imm = 0x1C8
pushq $-0xa
popq %rdx
leaq 0x38(%rsp), %r15
leaq 0x1afd7(%rip), %rbp     # 0x8d647
leaq 0x1ef7b(%rip), %rbx     # 0x915f2
cmpl $0x14, %edx
je 0x7277b
pushq $0xe
popq %rcx
cmpl %ecx, %edx
movq %rbx, %r14
movq %rbp, %rbx
movl %ecx, %ebp
cmovll %edx, %ebp
cmpl $0x6, %ebp
pushq $0x5
popq %rax
cmovll %eax, %ebp
cmpl $0x6, %edx
movl %eax, %r13d
movl %edx, 0x8(%rsp)
cmovgel %edx, %r13d
movl %ebp, 0xc(%rsp)
cmpl $0xe, %r13d
cmovgel %ecx, %r13d
leaq 0x18(%rsp), %r12
movq %r12, %rdi
leaq 0x37ebc(%rip), %rsi     # 0xaa57e
leaq 0x7(%rsp), %rdx
callq 0x66a0
xorl %esi, %esi
cmpl %ebp, %r13d
movq %rbx, %rbp
movq %r14, %rbx
sete %sil
movq %r15, %rdi
movq %r12, %rdx
callq 0x6894
movq %r15, %rdi
movq %rbp, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x37e9a(%rip), %rsi     # 0xaa595
callq 0x46c4c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x106fe
movq %r13, 0x10(%rsp)
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x107ba
movq %rax, %rdi
movq %rbp, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x37e5b(%rip), %rsi     # 0xaa58d
callq 0x107f4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0xc(%rsp), %rsi
callq 0x10736
movq %rax, %rdi
leaq 0x32b49(%rip), %rsi     # 0xa52a2
callq 0x106fe
movq %r15, %rdi
callq 0x68d4
leaq 0x18(%rsp), %rdi
callq 0x2090
movl 0x8(%rsp), %edx
incl %edx
jmp 0x72677
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x727a1
jmp 0x72794
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x68d4
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x10(%rsp), %rbx
leaq 0x38(%rsp), %rdi
movq %rbx, 0x8(%rdi)
movl $0x1, (%rbx)
callq 0x172e2
movl (%rbx), %ebp
leaq 0x37dd2(%rip), %rsi     # 0xaa5b8
leaq 0x18(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x66a0
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
leaq 0x38(%rsp), %rdi
movq %rbx, %rdx
callq 0x6894
leaq 0x1ae32(%rip), %rsi     # 0x8d647
leaq 0x38(%rsp), %rdi
callq 0x106fe
leaq 0x27d0c(%rip), %rsi     # 0x9a532
movq %rax, %rdi
callq 0x223dc
leaq 0x1edbd(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x10736
leaq 0x1adf6(%rip), %rsi     # 0x8d647
movq %rax, %rdi
callq 0x106fe
leaq 0x2249c(%rip), %rsi     # 0x94cfc
movq %rax, %rdi
callq 0x106fe
leaq 0x1ed83(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x14(%rsp), %rsi
movl $0x1, (%rsi)
movq %rax, %rdi
callq 0x10736
leaq 0x32a11(%rip), %rsi     # 0xa52a2
movq %rax, %rdi
callq 0x106fe
leaq 0x38(%rsp), %rdi
callq 0x68d4
leaq 0x18(%rsp), %rdi
callq 0x2090
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
jmp 0x728be
movq %rax, %rbx
jmp 0x728cb
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x68d4
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
leaq 0x10(%rsp), %rbx
leaq 0x38(%rsp), %rdi
movq %rbx, 0x8(%rdi)
movl $0x1, (%rbx)
callq 0x172e2
movl (%rbx), %ebp
leaq 0x36d8f(%rip), %rsi     # 0xaa5b8
leaq 0x18(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x66a0
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
leaq 0x38(%rsp), %rdi
movq %rbx, %rdx
callq 0x6894
leaq 0x19def(%rip), %rsi     # 0x8d647
leaq 0x38(%rsp), %rdi
callq 0x106fe
leaq 0x26cc9(%rip), %rsi     # 0x9a532
movq %rax, %rdi
callq 0x223dc
leaq 0x1dd7a(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x10736
leaq 0x19db3(%rip), %rsi     # 0x8d647
movq %rax, %rdi
callq 0x106fe
leaq 0x21459(%rip), %rsi     # 0x94cfc
movq %rax, %rdi
callq 0x106fe
leaq 0x1dd40(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x14(%rsp), %rsi
movl $0x1, (%rsi)
movq %rax, %rdi
callq 0x10736
leaq 0x319ce(%rip), %rsi     # 0xa52a2
movq %rax, %rdi
callq 0x106fe
leaq 0x38(%rsp), %rdi
callq 0x68d4
leaq 0x18(%rsp), %rdi
callq 0x2090
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %rbp
retq
jmp 0x73901
movq %rax, %rbx
jmp 0x7390e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x68d4
leaq 0x18(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x5
popq %r13
leaq 0x35e1d(%rip), %rbx     # 0xaa713
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
leaq 0x7f8(%rsp), %r12
pushq $0x1
popq %rbp
subl $0x1, %r13d
jb 0x7493e
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x66a0
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x6894
movq %r12, %rdi
callq 0x68d4
movq %r14, %rdi
callq 0x2090
jmp 0x7490b
leaq 0x35ddf(%rip), %rsi     # 0xaa724
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x668(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x668(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35daf(%rip), %rsi     # 0xaa736
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x4d8(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x4d8(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35d7f(%rip), %rsi     # 0xaa748
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x348(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x348(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35d4e(%rip), %rsi     # 0xaa759
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x1b8(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x1b8(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35d2d(%rip), %rsi     # 0xaa77a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x28(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
addq $0x988, %rsp            # imm = 0x988
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74aa8
jmp 0x74aa8
jmp 0x74aa8
jmp 0x74aa8
jmp 0x74aa8
jmp 0x74aad
jmp 0x74aad
jmp 0x74aad
jmp 0x74aad
jmp 0x74aad
movq %rax, %rbx
jmp 0x74aba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x5
popq %r13
leaq 0x35cd2(%rip), %rbx     # 0xaa7b0
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %r15
leaq 0x7f8(%rsp), %r12
pushq $0x1
popq %rbp
subl $0x1, %r13d
jb 0x74b26
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x66a0
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x6894
movq %r12, %rdi
callq 0x68d4
movq %r14, %rdi
callq 0x2090
jmp 0x74af3
leaq 0x35c94(%rip), %rsi     # 0xaa7c1
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x668(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x668(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35c64(%rip), %rsi     # 0xaa7d3
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x4d8(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x4d8(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35c34(%rip), %rsi     # 0xaa7e5
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x348(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x348(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35c03(%rip), %rsi     # 0xaa7f6
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x1b8(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x1b8(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x35be2(%rip), %rsi     # 0xaa817
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x66a0
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x8(%rsp), %rdx
callq 0x6894
leaq 0x28(%rsp), %rdi
callq 0x68d4
leaq 0x8(%rsp), %rdi
callq 0x2090
addq $0x988, %rsp            # imm = 0x988
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74c90
jmp 0x74c90
jmp 0x74c90
jmp 0x74c90
jmp 0x74c90
jmp 0x74c95
jmp 0x74c95
jmp 0x74c95
jmp 0x74c95
jmp 0x74c95
movq %rax, %rbx
jmp 0x74ca2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x60(%rsp), %rdi
andq $0x0, (%rdi)
pushq $0xa
popq %rax
movq %rax, 0x8(%rdi)
leaq 0x18(%rsp), %rbx
andq $0x0, (%rbx)
pushq $0x1
popq %rcx
movq %rcx, 0x10(%rdi)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq %rbx, %rsi
callq 0x3c2b4
pushq $0x5
popq %r15
movq %r15, (%rbx)
pushq $0xf
popq %r12
movq %r12, 0x8(%rbx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rbx)
leaq 0x48(%rsp), %rbx
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146da
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r12, 0x8(%rsi)
movq %rbx, %rdi
callq 0x3c7da
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146da
leaq 0x30(%rsp), %rsi
movq %r15, (%rsi)
movq %r12, 0x8(%rsi)
movq %rbx, %rdi
callq 0x3c7da
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/test/shape.cpp
// Function: nda::test_dim_set_stride_body()
TEST(dim_set_stride) {
  dim<> x(3, 10, 4);
  x.set_stride(5);
  ASSERT_EQ(x.stride(), 5);

  dim<dynamic, dynamic, 4> y(100, 120);
  // set_stride(unresolved) is a valid noop on a static stride.
  y.set_stride(unresolved);
  ASSERT_EQ(y.stride(), 4);

  // Uncommenting this will cause an assertion failure.
  // y.set_stride(5);
}

// Assembly:
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
leaq 0x357f2(%rip), %rsi     # 0xaa914
leaq 0x10(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x66a0
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x6894
leaq 0x184fd(%rip), %rsi     # 0x8d647
leaq 0x30(%rsp), %rdi
callq 0x106fe
leaq 0x357c9(%rip), %rsi     # 0xaa924
movq %rax, %rdi
callq 0x107d8
leaq 0x1c488(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x8(%rsp), %rsi
movq $0x5, (%rsi)
movq %rax, %rdi
callq 0x107ba
leaq 0x184ba(%rip), %rsi     # 0x8d647
movq %rax, %rdi
callq 0x106fe
leaq 0x1a37d(%rip), %rsi     # 0x8f519
movq %rax, %rdi
callq 0x106fe
leaq 0x1c447(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x4(%rsp), %rsi
movl $0x5, (%rsi)
movq %rax, %rdi
callq 0x10736
leaq 0x300d5(%rip), %rsi     # 0xa52a2
movq %rax, %rdi
callq 0x106fe
leaq 0x30(%rsp), %rdi
callq 0x68d4
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x3573f(%rip), %rsi     # 0xaa92f
leaq 0x10(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x66a0
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
callq 0x6894
leaq 0x1842f(%rip), %rsi     # 0x8d647
leaq 0x30(%rsp), %rdi
callq 0x106fe
leaq 0x35716(%rip), %rsi     # 0xaa93f
movq %rax, %rdi
callq 0x107d8
leaq 0x1c3ba(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x8(%rsp), %rsi
movq $0x4, (%rsi)
movq %rax, %rdi
callq 0x107ba
leaq 0x183ec(%rip), %rsi     # 0x8d647
movq %rax, %rdi
callq 0x106fe
leaq 0x1d10a(%rip), %rsi     # 0x92374
movq %rax, %rdi
callq 0x106fe
leaq 0x1c379(%rip), %rsi     # 0x915f2
movq %rax, %rdi
callq 0x106fe
leaq 0x4(%rsp), %rsi
movl $0x4, (%rsi)
movq %rax, %rdi
callq 0x10736
leaq 0x30007(%rip), %rsi     # 0xa52a2
movq %rax, %rdi
callq 0x106fe
leaq 0x30(%rsp), %rdi
callq 0x68d4
leaq 0x10(%rsp), %rdi
callq 0x2090
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
retq
jmp 0x752c2
movq %rax, %rbx
jmp 0x752fc
jmp 0x752d6
jmp 0x752cd
jmp 0x752e5
movq %rax, %rbx
jmp 0x752f2
jmp 0x752d6
jmp 0x752e5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x68d4
jmp 0x752f2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x68d4
leaq 0x10(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_number_theory_body()
TEST(shape_number_theory) {
  test_number_theory(shape_of_rank<2>({1, 10}, {3, 5}));
  test_number_theory(shape_of_rank<2>({-1, 10}, {3, 5, -1}));
  test_number_theory(shape_of_rank<2>({-2, 10, 6}, {3, 5}));
  test_number_theory(shape_of_rank<3>({0, 4, 4}, {0, 4, 2}, {0, 4, 1}));
  // TODO: https://github.com/dsharlet/array/issues/2
  // test_number_theory(shape_of_rank<2>({0, 4, 4}, {0, 4, 4}));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
pushq $0x3
popq %r14
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
pushq $0x5
popq %r15
movq %r15, 0x8(%rdi)
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
movq %r12, 0x10(%rdi)
pushq $0x1
popq %rbx
movq %rbx, 0x18(%rdi)
pushq $0xa
popq %r13
movq %r13, 0x20(%rdi)
movq %r12, 0x28(%rdi)
callq 0x778dc
leaq 0x38(%rsp), %rdi
movq %r14, (%rdi)
movq %r15, 0x8(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movq %r13, 0x20(%rdi)
movq %r12, 0x28(%rdi)
callq 0x778dc
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
movq %r15, 0x8(%rdi)
movq %r12, 0x10(%rdi)
movq $-0x2, 0x18(%rdi)
movq %r13, 0x20(%rdi)
movq $0x6, 0x28(%rdi)
callq 0x778dc
leaq 0x98(%rsp), %rdi
andq $0x0, (%rdi)
pushq $0x4
popq %rax
movq %rax, 0x8(%rdi)
movq %rbx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0x2, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
callq 0x77b8f
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsharlet[P]array/test/sort.cpp
// Function: nda::test_sort_body()
TEST(sort) {
  for (int size = 0; size < 100; size++) {
    std::vector<int> unordered(size);
    for (int& i : unordered) {
      i = rand() % 100;
    }

    std::vector<int> std_sorted(unordered);
    std::vector<int> sorted(unordered);

    std::sort(std_sorted.begin(), std_sorted.end());
    internal::bubble_sort(sorted.begin(), sorted.end());

    for (size_t i = 0; i < unordered.size(); i++) {
      ASSERT_EQ(std_sorted[i], sorted[i]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
xorl %esi, %esi
leaq 0x10(%rsp), %rbx
leaq 0x88(%rsp), %rbp
leaq 0x6480(%rip), %r14      # 0x8d647
cmpq $0x64, %rsi
je 0x87379
movq %rbx, %rdi
movq %rsi, 0x58(%rsp)
movq %rbp, %rdx
callq 0x873ea
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r13
cmpq %r13, %rbx
je 0x87203
callq 0x2320
cltd
pushq $0x64
popq %rcx
idivl %ecx
movl %edx, (%rbx)
addq $0x4, %rbx
jmp 0x871eb
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x8743c
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x8743c
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x874dd
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x87489
xorl %ebx, %ebx
xorl %ecx, %ecx
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x2, %rax
cmpq %rax, %rcx
jae 0x8734b
movq %rcx, 0x60(%rsp)
movq %rbp, %r12
movq %r14, %r13
movq 0x40(%rsp), %rax
movl (%rax,%rbx), %r14d
movq 0x28(%rsp), %rax
movl (%rax,%rbx), %ebp
leaq 0x68(%rsp), %r15
movq %r15, %rdi
leaq 0x24c00(%rip), %rsi     # 0xabe86
leaq 0xf(%rsp), %rdx
callq 0x66a0
xorl %esi, %esi
cmpl %ebp, %r14d
sete %sil
movq %r12, %rbp
movq %r12, %rdi
movq %r15, %rdx
callq 0x6894
leaq 0xa344(%rip), %r12      # 0x915f2
movq %r13, %r14
movq %rbp, %rdi
movq %r13, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x24bdb(%rip), %rsi     # 0xabea1
callq 0x1085e
movq %rax, %rdi
movq %r12, %rsi
callq 0x106fe
movq 0x40(%rsp), %rsi
addq %rbx, %rsi
movq %rax, %rdi
callq 0x10736
movq %rax, %rdi
movq %r14, %rsi
callq 0x106fe
movq %rax, %rdi
leaq 0x24b9c(%rip), %rsi     # 0xabe97
callq 0x1079e
movq %rax, %rdi
movq %r12, %rsi
callq 0x106fe
movq 0x28(%rsp), %rsi
addq %rbx, %rsi
movq %rax, %rdi
callq 0x10736
movq %rax, %rdi
leaq 0x1df7d(%rip), %rsi     # 0xa52a2
callq 0x106fe
movq %rbp, %rdi
callq 0x68d4
movq %r15, %rdi
callq 0x2090
movq 0x60(%rsp), %rcx
incq %rcx
addq $0x4, %rbx
jmp 0x87244
leaq 0x28(%rsp), %rdi
callq 0x84b88
leaq 0x40(%rsp), %rdi
callq 0x84b88
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x84b88
movq 0x58(%rsp), %rsi
incq %rsi
jmp 0x871c7
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x873cf
movq %rax, %rbx
jmp 0x873c5
jmp 0x87397
movq %rax, %rbx
jmp 0x873bb
movq %rax, %rbx
jmp 0x873b1
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x68d4
leaq 0x68(%rsp), %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
callq 0x84b88
leaq 0x40(%rsp), %rdi
callq 0x84b88
leaq 0x10(%rsp), %rdi
callq 0x84b88
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x6bba
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
pushq $0x2
popq %r14
pushq $0x3
popq %r15
pushq $0x4
popq %r12
pushq $0x5
popq %r13
movq %rbx, %rbp
cmpq $0x64, %rbp
je 0x88442
xorl %edi, %edi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x8820b
xorl %edi, %edi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x8820b
xorl %edi, %edi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x8820b
xorl %edi, %edi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x8820b
xorl %edi, %edi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x8820b
xorl %edi, %edi
movq %rbp, %rsi
callq 0x89014
cmpq $0x2, %rbp
jb 0x8843a
xorl %edi, %edi
movq %rbp, %rsi
callq 0x8916a
cmpq $0x2, %rbp
je 0x8843a
xorl %edi, %edi
movq %rbp, %rsi
callq 0x892e5
cmpq $0x4, %rbp
jb 0x8843a
xorl %edi, %edi
movq %rbp, %rsi
callq 0x89464
cmpq $0x4, %rbp
je 0x8843a
xorl %edi, %edi
movq %rbp, %rsi
callq 0x895e3
incq %rbp
jmp 0x883a5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
leaq 0x7558(%rip), %rsi      # 0x916f5
callq 0x21c0
leaq 0x7551(%rip), %rsi      # 0x916fa
movq %r14, %rdi
callq 0x21c0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x16441
leaq 0x502d(%rip), %rsi      # 0x8f1f4
movq %r14, %rdi
callq 0x21c0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq