LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dsharlet[P]array/include/array/image.h
// Function: nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>> nda::crop_image_shape<nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>>(nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, long, long, long, long, nda::crop_origin)
Shape crop_image_shape(Shape s, index_t x0, index_t y0, index_t x1, index_t y1,
    crop_origin origin = crop_origin::crop) {
  s.x().set_extent(x1 - x0);
  s.y().set_extent(y1 - y0);
  switch (origin) {
  case crop_origin::zero:
    s.x().set_min(0);
    s.y().set_min(0);
    break;
  case crop_origin::crop:
    s.x().set_min(x0);
    s.y().set_min(y0);
    break;
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rax, -0xb0(%rbp)
movq %rax, %rsi
movq %rsi, -0xa8(%rbp)
movl 0x10(%rbp), %esi
movq %rax, -0x68(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movq %r9, -0x90(%rbp)
callq 0x10c510
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq -0x78(%rbp), %rdx
subq %rdx, %rax
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x8, %rdi
callq 0x12bf0
movq -0xa0(%rbp), %rdi
callq 0x10c550
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq -0x80(%rbp), %rdx
subq %rdx, %rax
movq %rcx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x8, %rdi
callq 0x12bf0
movl 0x10(%rbp), %eax
movl %eax, -0x94(%rbp)
testl %eax, %eax
je 0x10cd42
jmp 0x10cd32
movl -0x94(%rbp), %eax
subl $0x1, %eax
je 0x10cd8e
jmp 0x10cdde
movq -0xa0(%rbp), %rdi
callq 0x10c510
movq %rax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x12bf0
movq -0xa0(%rbp), %rdi
callq 0x10c550
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12bf0
jmp 0x10cdde
movq -0xa0(%rbp), %rdi
callq 0x10c510
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x12bf0
movq -0xa0(%rbp), %rdi
callq 0x10c550
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x12bf0
movq -0xa0(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x16720
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x48(%rbp), %rdi
callq 0x143b50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rdi
callq 0x143b70
movq %rax, %rcx
movq -0xb0(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x143b30
movq -0x48(%rbp), %rdi
callq 0x143b70
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
imulq -0x60(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x48(%rbp), %rdi
callq 0x143b70
movq -0xb8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdx
imulq -0x60(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
movl $0x1, %ecx
callq 0x16d70
movq -0x48(%rbp), %rdi
callq 0x143b90
movq %rax, %rdx
leaq -0x90(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x349d0
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x102650
jmp 0x143b41
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x102750
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x145a2f
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x145a2f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x145a1f
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3f, %ecx
movb %al, -0x19(%rbp)
jne 0x145a2f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x145a38
jmp 0x145a52
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1459e0
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x145a6f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x145acb
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x145ab8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1459d0
testb $0x1, %al
jne 0x145a9a
jmp 0x145aa0
movb $0x1, -0x1(%rbp)
jmp 0x145acb
jmp 0x145aa2
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
jne 0x145a87
jmp 0x145ab8
jmp 0x145aba
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movl $0x5, %esi
movl $0x8, %edx
callq 0x149bd0
movq -0xe8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x34a90
movq -0xe0(%rbp), %rdi
xorl %esi, %esi
callq 0x149e50
jmp 0x14712c
leaq -0xc8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x149e80
jmp 0x14713e
leaq -0x50(%rbp), %rdi
callq 0x149ee0
movq %rax, -0xf0(%rbp)
jmp 0x147150
movq -0xf0(%rbp), %rdi
leaq -0x50(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xc8(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0xd8(%rbp), %rsi
callq 0x1471c0
jmp 0x14717e
leaq -0x50(%rbp), %rdi
callq 0x34c80
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34c80
movq -0x88(%rbp), %rdi
callq 0x33a0
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x78(%rbp)
jl 0x1732c7
jmp 0x1732e6
leaq 0x863c8(%rip), %rdi     # 0x1f9696
leaq 0x68e0c(%rip), %rsi     # 0x1dc0e1
movl $0x21d, %edx            # imm = 0x21D
leaq 0x863bc(%rip), %rcx     # 0x1f969d
callq 0x3130
movq -0x90(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movq -0x40(%rbp), %rdx
movq (%rdx), %rdx
imulq -0x78(%rbp), %rdx
addq %rdx, %rax
movq %rcx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12bf0
movq -0x90(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
addq (%rcx), %rax
subq $0x1, %rax
movq %rax, -0x88(%rbp)
addq $0x10, %rsi
leaq -0x88(%rbp), %rdi
callq 0x124b0
movq -0x90(%rbp), %rcx
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq -0x68(%rbp), %rdx
movq %rdx, -0x60(%rbp)
movq -0x60(%rbp), %rdx
subq (%rdx), %rax
addq $0x1, %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x12bf0
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
leaq -0x18(%rbp), %rdi
movl $0x5, %esi
movl $0xa, %edx
movl $0x1, %ecx
callq 0x10c60
movl $0xfffffff6, -0x1c(%rbp) # imm = 0xFFFFFFF6
cmpl $0x14, -0x1c(%rbp)
jge 0x17f7cb
movl $0xe, -0x24(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x18ae90
movq %rax, %rdi
movl $0x5, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xf0570
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movslq -0x1c(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x18aed0
movslq -0x20(%rbp), %rcx
subq %rcx, %rax
sete %al
movb %al, -0x201(%rbp)
leaq -0x1d9(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x33b0
movq -0x200(%rbp), %rdx
leaq 0x7c1c1(%rip), %rsi     # 0x1fb7af
leaq -0x1d8(%rbp), %rdi
callq 0x10a90
jmp 0x17f5fc
movb -0x201(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1b8(%rbp), %rdi
leaq -0x1d8(%rbp), %rdx
callq 0x10f80
jmp 0x17f61d
leaq 0x5d1c1(%rip), %rsi     # 0x1dc7e5
leaq -0x1b8(%rbp), %rdi
callq 0x34320
movq %rax, -0x210(%rbp)
jmp 0x17f639
movq -0x210(%rbp), %rdi
leaq 0x7c17f(%rip), %rsi     # 0x1fb7c6
callq 0xc7360
movq %rax, -0x218(%rbp)
jmp 0x17f655
movq -0x218(%rbp), %rdi
leaq 0x61149(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x220(%rbp)
jmp 0x17f671
movslq -0x1c(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x18aed0
movq %rax, -0x228(%rbp)
jmp 0x17f687
movq -0x220(%rbp), %rdi
movq -0x228(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1f8(%rbp), %rsi
callq 0x34510
movq %rax, -0x230(%rbp)
jmp 0x17f6b1
movq -0x230(%rbp), %rdi
leaq 0x5d126(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x238(%rbp)
jmp 0x17f6cd
movq -0x238(%rbp), %rdi
leaq 0x7c0e3(%rip), %rsi     # 0x1fb7be
callq 0x34600
movq %rax, -0x240(%rbp)
jmp 0x17f6e9
movq -0x240(%rbp), %rdi
leaq 0x610b5(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x248(%rbp)
jmp 0x17f705
movq -0x248(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x343a0
movq %rax, -0x250(%rbp)
jmp 0x17f71e
movq -0x250(%rbp), %rdi
leaq 0x76d4f(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x17f733
leaq -0x1b8(%rbp), %rdi
callq 0x10ff0
jmp 0x17f741
leaq -0x1d8(%rbp), %rdi
callq 0x3100
leaq -0x1d9(%rbp), %rdi
callq 0x3290
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17f57a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
jmp 0x17f7bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
jmp 0x17f7b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x10ff0
jmp 0x17f7af
jmp 0x17f7b1
leaq -0x1d8(%rbp), %rdi
callq 0x3100
leaq -0x1d9(%rbp), %rdi
callq 0x3290
jmp 0x17f7d4
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x1e8(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
leaq -0x1(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x1d390
movq -0x200(%rbp), %rdi
movl $0x0, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x17fa30
movl -0x8(%rbp), %eax
subl $0x1, %eax
sete %al
movb %al, -0x1f1(%rbp)
leaq -0x1d1(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x33b0
movq -0x1f0(%rbp), %rdx
leaq 0x7bf8f(%rip), %rsi     # 0x1fb7e9
leaq -0x1d0(%rbp), %rdi
callq 0x10a90
jmp 0x17f868
movb -0x1f1(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1b0(%rbp), %rdi
leaq -0x1d0(%rbp), %rdx
callq 0x10f80
jmp 0x17f889
leaq 0x5cf55(%rip), %rsi     # 0x1dc7e5
leaq -0x1b0(%rbp), %rdi
callq 0x34320
movq %rax, -0x208(%rbp)
jmp 0x17f8a5
movq -0x208(%rbp), %rdi
leaq 0x6a1fb(%rip), %rsi     # 0x1e9aae
callq 0x661c0
movq %rax, -0x210(%rbp)
jmp 0x17f8c1
movq -0x210(%rbp), %rdi
leaq 0x60edd(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x218(%rbp)
jmp 0x17f8dd
movq -0x218(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x343a0
movq %rax, -0x220(%rbp)
jmp 0x17f8f6
movq -0x220(%rbp), %rdi
leaq 0x5cee1(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x228(%rbp)
jmp 0x17f912
movq -0x228(%rbp), %rdi
leaq 0x6474d(%rip), %rsi     # 0x1e406d
callq 0x34320
movq %rax, -0x230(%rbp)
jmp 0x17f92e
movq -0x230(%rbp), %rdi
leaq 0x60e70(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x238(%rbp)
jmp 0x17f94a
movq -0x238(%rbp), %rdi
movl $0x1, -0x1e8(%rbp)
leaq -0x1e8(%rbp), %rsi
callq 0x343a0
movq %rax, -0x240(%rbp)
jmp 0x17f970
movq -0x240(%rbp), %rdi
leaq 0x76afd(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x17f985
leaq -0x1b0(%rbp), %rdi
callq 0x10ff0
jmp 0x17f993
leaq -0x1d0(%rbp), %rdi
callq 0x3100
leaq -0x1d1(%rbp), %rdi
callq 0x3290
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x17fa0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x17f9fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x10ff0
jmp 0x17f9fc
jmp 0x17f9fe
leaq -0x1d0(%rbp), %rdi
callq 0x3100
leaq -0x1d1(%rbp), %rdi
callq 0x3290
movq -0x1e0(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopw (%rax,%rax)
// File: dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_all_indices_1d_body()
TEST(for_all_indices_1d) {
  dense_shape<1> s(20);
  int expected_flat_offset = 0;
  for_all_indices(s, [&](int x) {
    ASSERT_EQ(s(x), expected_flat_offset);
    expected_flat_offset++;
  });
  // Ensure the for_all_indices loop above actually ran.
  ASSERT_EQ(expected_flat_offset, 20);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
leaq -0x18(%rbp), %rdi
movq %rdi, -0x210(%rbp)
movl $0x14, %esi
callq 0x34210
movq -0x210(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
movq %rdi, -0x30(%rbp)
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x17fcc0
movl -0x1c(%rbp), %eax
subl $0x14, %eax
sete %al
movb %al, -0x201(%rbp)
leaq -0x1e1(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x33b0
movq -0x200(%rbp), %rdx
leaq 0x7bd24(%rip), %rsi     # 0x1fb807
leaq -0x1e0(%rbp), %rdi
callq 0x10a90
jmp 0x17faf1
movb -0x201(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1c0(%rbp), %rdi
leaq -0x1e0(%rbp), %rdx
callq 0x10f80
jmp 0x17fb12
leaq 0x5cccc(%rip), %rsi     # 0x1dc7e5
leaq -0x1c0(%rbp), %rdi
callq 0x34320
movq %rax, -0x218(%rbp)
jmp 0x17fb2e
movq -0x218(%rbp), %rdi
leaq 0x7d0d9(%rip), %rsi     # 0x1fcc15
callq 0x96ac0
movq %rax, -0x220(%rbp)
jmp 0x17fb4a
movq -0x220(%rbp), %rdi
leaq 0x60c54(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x228(%rbp)
jmp 0x17fb66
movq -0x228(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x343a0
movq %rax, -0x230(%rbp)
jmp 0x17fb7f
movq -0x230(%rbp), %rdi
leaq 0x5cc58(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x238(%rbp)
jmp 0x17fb9b
movq -0x238(%rbp), %rdi
leaq 0x5ebdf(%rip), %rsi     # 0x1de788
callq 0x34840
movq %rax, -0x240(%rbp)
jmp 0x17fbb7
movq -0x240(%rbp), %rdi
leaq 0x60be7(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x248(%rbp)
jmp 0x17fbd3
movq -0x248(%rbp), %rdi
movl $0x14, -0x1f8(%rbp)
leaq -0x1f8(%rbp), %rsi
callq 0x343a0
movq %rax, -0x250(%rbp)
jmp 0x17fbf9
movq -0x250(%rbp), %rdi
leaq 0x76874(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x17fc0e
leaq -0x1c0(%rbp), %rdi
callq 0x10ff0
jmp 0x17fc1c
leaq -0x1e0(%rbp), %rdi
callq 0x3100
leaq -0x1e1(%rbp), %rdi
callq 0x3290
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0x17fc93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0x17fc87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x10ff0
jmp 0x17fc85
jmp 0x17fc87
leaq -0x1e0(%rbp), %rdi
callq 0x3100
leaq -0x1e1(%rbp), %rdi
callq 0x3290
movq -0x1f0(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopw %cs:(%rax,%rax)
// File: dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_all_indices_2d_body()
TEST(for_all_indices_2d) {
  dense_shape<2> s(10, 4);
  s.resolve();
  int expected_flat_offset = 0;
  for_all_indices(s, [&](int x, int y) {
    ASSERT_EQ(s(x, y), expected_flat_offset);
    expected_flat_offset++;
  });
  // Ensure the for_all_indices loop above actually ran.
  ASSERT_EQ(expected_flat_offset, 40);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
leaq -0x30(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movl $0xa, %esi
movl $0x4, %edx
callq 0x343e0
movq -0x228(%rbp), %rdi
callq 0x3cca0
movq -0x228(%rbp), %rdi
movl $0x0, -0x34(%rbp)
movq %rdi, -0x48(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x17ff60
movl -0x34(%rbp), %eax
subl $0x28, %eax
sete %al
movb %al, -0x219(%rbp)
leaq -0x1f9(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x33b0
movq -0x218(%rbp), %rdx
leaq 0x7bab1(%rip), %rsi     # 0x1fb835
leaq -0x1f8(%rbp), %rdi
callq 0x10a90
jmp 0x17fd92
movb -0x219(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1d8(%rbp), %rdi
leaq -0x1f8(%rbp), %rdx
callq 0x10f80
jmp 0x17fdb3
leaq 0x5ca2b(%rip), %rsi     # 0x1dc7e5
leaq -0x1d8(%rbp), %rdi
callq 0x34320
movq %rax, -0x230(%rbp)
jmp 0x17fdcf
movq -0x230(%rbp), %rdi
leaq 0x7ce38(%rip), %rsi     # 0x1fcc15
callq 0x96ac0
movq %rax, -0x238(%rbp)
jmp 0x17fdeb
movq -0x238(%rbp), %rdi
leaq 0x609b3(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x240(%rbp)
jmp 0x17fe07
movq -0x240(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x343a0
movq %rax, -0x248(%rbp)
jmp 0x17fe20
movq -0x248(%rbp), %rdi
leaq 0x5c9b7(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x250(%rbp)
jmp 0x17fe3c
movq -0x250(%rbp), %rdi
leaq 0x6e9ec(%rip), %rsi     # 0x1ee836
callq 0x34840
movq %rax, -0x258(%rbp)
jmp 0x17fe58
movq -0x258(%rbp), %rdi
leaq 0x60946(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x260(%rbp)
jmp 0x17fe74
movq -0x260(%rbp), %rdi
movl $0x28, -0x210(%rbp)
leaq -0x210(%rbp), %rsi
callq 0x343a0
movq %rax, -0x268(%rbp)
jmp 0x17fe9a
movq -0x268(%rbp), %rdi
leaq 0x765d3(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x17feaf
leaq -0x1d8(%rbp), %rdi
callq 0x10ff0
jmp 0x17febd
leaq -0x1f8(%rbp), %rdi
callq 0x3100
leaq -0x1f9(%rbp), %rdi
callq 0x3290
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
jmp 0x17ff34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
jmp 0x17ff28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x10ff0
jmp 0x17ff26
jmp 0x17ff28
leaq -0x1f8(%rbp), %rdi
callq 0x3100
leaq -0x1f9(%rbp), %rdi
callq 0x3290
movq -0x208(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopw %cs:(%rax,%rax)
// File: dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_all_indices_3d_body()
TEST(for_all_indices_3d) {
  dense_shape<3> s(3, 5, 8);
  s.resolve();
  int expected_flat_offset = 0;
  move_only token;
  for_all_indices(s, [&, token = std::move(token)](int x, int y, int z) {
    ASSERT_EQ(s(x, y, z), expected_flat_offset);
    expected_flat_offset++;
    assert_used(token);
  });
  // Ensure the for_all_indices loop above actually ran.
  ASSERT_EQ(expected_flat_offset, 120);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
leaq -0x48(%rbp), %rdi
movq %rdi, -0x248(%rbp)
movl $0x3, %esi
movl $0x5, %edx
movl $0x8, %ecx
callq 0x34640
movq -0x248(%rbp), %rdi
callq 0x11be0
movq -0x248(%rbp), %rdi
movl $0x0, -0x4c(%rbp)
movq %rdi, -0x60(%rbp)
leaq -0x4c(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x180200
movl -0x4c(%rbp), %eax
subl $0x78, %eax
sete %al
movb %al, -0x239(%rbp)
leaq -0x219(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x33b0
movq -0x238(%rbp), %rdx
leaq 0x7b83a(%rip), %rsi     # 0x1fb863
leaq -0x218(%rbp), %rdi
callq 0x10a90
jmp 0x180037
movb -0x239(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1f8(%rbp), %rdi
leaq -0x218(%rbp), %rdx
callq 0x10f80
jmp 0x180058
leaq 0x5c786(%rip), %rsi     # 0x1dc7e5
leaq -0x1f8(%rbp), %rdi
callq 0x34320
movq %rax, -0x250(%rbp)
jmp 0x180074
movq -0x250(%rbp), %rdi
leaq 0x7cb93(%rip), %rsi     # 0x1fcc15
callq 0x96ac0
movq %rax, -0x258(%rbp)
jmp 0x180090
movq -0x258(%rbp), %rdi
leaq 0x6070e(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x260(%rbp)
jmp 0x1800ac
movq -0x260(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x343a0
movq %rax, -0x268(%rbp)
jmp 0x1800c5
movq -0x268(%rbp), %rdi
leaq 0x5c712(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x270(%rbp)
jmp 0x1800e1
movq -0x270(%rbp), %rdi
leaq 0x7b78c(%rip), %rsi     # 0x1fb87b
callq 0x356d0
movq %rax, -0x278(%rbp)
jmp 0x1800fd
movq -0x278(%rbp), %rdi
leaq 0x606a1(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x280(%rbp)
jmp 0x180119
movq -0x280(%rbp), %rdi
movl $0x78, -0x230(%rbp)
leaq -0x230(%rbp), %rsi
callq 0x343a0
movq %rax, -0x288(%rbp)
jmp 0x18013f
movq -0x288(%rbp), %rdi
leaq 0x7632e(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x180154
leaq -0x1f8(%rbp), %rdi
callq 0x10ff0
jmp 0x180162
leaq -0x218(%rbp), %rdi
callq 0x3100
leaq -0x219(%rbp), %rdi
callq 0x3290
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x1801d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x1801cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x10ff0
jmp 0x1801cb
jmp 0x1801cd
leaq -0x218(%rbp), %rdi
callq 0x3100
leaq -0x219(%rbp), %rdi
callq 0x3290
movq -0x228(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopl (%rax)
// File: dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_all_indices_2d_of_3d_body()
TEST(for_all_indices_2d_of_3d) {
  shape_of_rank<3> s(3, 5, {0, 8, 1});
  s.resolve();
  int expected_flat_offset = 0;
  for_all_indices<0, 1>(s, [&](int x, int y) {
    ASSERT_EQ(s(x, y, 0), expected_flat_offset);
    expected_flat_offset += s.x().stride();
  });
  // Ensure the for_all_indices loop above actually ran.
  ASSERT_EQ(expected_flat_offset, 120);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
leaq -0x60(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
movl $0x3, %esi
callq 0x10c20
leaq -0x78(%rbp), %rdi
movq %rdi, -0x298(%rbp)
movl $0x5, %esi
callq 0x10c20
xorl %eax, %eax
movl %eax, %esi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x290(%rbp)
movl $0x8, %edx
movl $0x1, %ecx
callq 0x10c60
movq -0x2a0(%rbp), %rsi
movq -0x298(%rbp), %rdx
movq -0x290(%rbp), %rcx
leaq -0x48(%rbp), %rdi
movq %rdi, -0x288(%rbp)
callq 0x36640
movq -0x288(%rbp), %rdi
callq 0x378e0
movq -0x288(%rbp), %rdi
movl $0x0, -0x94(%rbp)
movq %rdi, -0xa8(%rbp)
leaq -0x94(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x180810
movl -0x94(%rbp), %eax
subl $0x78, %eax
sete %al
movb %al, -0x279(%rbp)
leaq -0x259(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x33b0
movq -0x278(%rbp), %rdx
leaq 0x7b227(%rip), %rsi     # 0x1fb863
leaq -0x258(%rbp), %rdi
callq 0x10a90
jmp 0x18064a
movb -0x279(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x238(%rbp), %rdi
leaq -0x258(%rbp), %rdx
callq 0x10f80
jmp 0x18066b
leaq 0x5c173(%rip), %rsi     # 0x1dc7e5
leaq -0x238(%rbp), %rdi
callq 0x34320
movq %rax, -0x2a8(%rbp)
jmp 0x180687
movq -0x2a8(%rbp), %rdi
leaq 0x7c580(%rip), %rsi     # 0x1fcc15
callq 0x96ac0
movq %rax, -0x2b0(%rbp)
jmp 0x1806a3
movq -0x2b0(%rbp), %rdi
leaq 0x600fb(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x2b8(%rbp)
jmp 0x1806bf
movq -0x2b8(%rbp), %rdi
leaq -0x94(%rbp), %rsi
callq 0x343a0
movq %rax, -0x2c0(%rbp)
jmp 0x1806db
movq -0x2c0(%rbp), %rdi
leaq 0x5c0fc(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x2c8(%rbp)
jmp 0x1806f7
movq -0x2c8(%rbp), %rdi
leaq 0x7b176(%rip), %rsi     # 0x1fb87b
callq 0x356d0
movq %rax, -0x2d0(%rbp)
jmp 0x180713
movq -0x2d0(%rbp), %rdi
leaq 0x6008b(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x2d8(%rbp)
jmp 0x18072f
movq -0x2d8(%rbp), %rdi
movl $0x78, -0x270(%rbp)
leaq -0x270(%rbp), %rsi
callq 0x343a0
movq %rax, -0x2e0(%rbp)
jmp 0x180755
movq -0x2e0(%rbp), %rdi
leaq 0x75d18(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x18076a
leaq -0x238(%rbp), %rdi
callq 0x10ff0
jmp 0x180778
leaq -0x258(%rbp), %rdi
callq 0x3100
leaq -0x259(%rbp), %rdi
callq 0x3290
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x268(%rbp)
movl %eax, -0x26c(%rbp)
jmp 0x1807ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x268(%rbp)
movl %eax, -0x26c(%rbp)
jmp 0x1807e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x268(%rbp)
movl %eax, -0x26c(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x10ff0
jmp 0x1807e1
jmp 0x1807e3
leaq -0x258(%rbp), %rdi
callq 0x3100
leaq -0x259(%rbp), %rdi
callq 0x3290
movq -0x268(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nop
// File: 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
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
leaq -0x1(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x1d390
movq -0x200(%rbp), %rdi
movl $0x0, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x180aa0
movl -0x8(%rbp), %eax
subl $0x1, %eax
sete %al
movb %al, -0x1f1(%rbp)
leaq -0x1d1(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
callq 0x33b0
movq -0x1f0(%rbp), %rdx
leaq 0x7af1f(%rip), %rsi     # 0x1fb7e9
leaq -0x1d0(%rbp), %rdi
callq 0x10a90
jmp 0x1808d8
movb -0x1f1(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1b0(%rbp), %rdi
leaq -0x1d0(%rbp), %rdx
callq 0x10f80
jmp 0x1808f9
leaq 0x5bee5(%rip), %rsi     # 0x1dc7e5
leaq -0x1b0(%rbp), %rdi
callq 0x34320
movq %rax, -0x208(%rbp)
jmp 0x180915
movq -0x208(%rbp), %rdi
leaq 0x6918b(%rip), %rsi     # 0x1e9aae
callq 0x661c0
movq %rax, -0x210(%rbp)
jmp 0x180931
movq -0x210(%rbp), %rdi
leaq 0x5fe6d(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x218(%rbp)
jmp 0x18094d
movq -0x218(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x343a0
movq %rax, -0x220(%rbp)
jmp 0x180966
movq -0x220(%rbp), %rdi
leaq 0x5be71(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x228(%rbp)
jmp 0x180982
movq -0x228(%rbp), %rdi
leaq 0x636dd(%rip), %rsi     # 0x1e406d
callq 0x34320
movq %rax, -0x230(%rbp)
jmp 0x18099e
movq -0x230(%rbp), %rdi
leaq 0x5fe00(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x238(%rbp)
jmp 0x1809ba
movq -0x238(%rbp), %rdi
movl $0x1, -0x1e8(%rbp)
leaq -0x1e8(%rbp), %rsi
callq 0x343a0
movq %rax, -0x240(%rbp)
jmp 0x1809e0
movq -0x240(%rbp), %rdi
leaq 0x75a8d(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x1809f5
leaq -0x1b0(%rbp), %rdi
callq 0x10ff0
jmp 0x180a03
leaq -0x1d0(%rbp), %rdi
callq 0x3100
leaq -0x1d1(%rbp), %rdi
callq 0x3290
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x180a7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x180a6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x10ff0
jmp 0x180a6c
jmp 0x180a6e
leaq -0x1d0(%rbp), %rdi
callq 0x3100
leaq -0x1d1(%rbp), %rdi
callq 0x3290
movq -0x1e0(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopw (%rax,%rax)
// File: dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_each_index_1d_body()
TEST(for_each_index_1d) {
  dense_shape<1> s(20);
  int expected_flat_offset = 0;
  for_each_index(s, [&](auto i) {
    ASSERT_EQ(s[i], expected_flat_offset);
    expected_flat_offset++;
  });
  // Ensure the for_each_index loop above actually ran.
  ASSERT_EQ(expected_flat_offset, 20);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
leaq -0x18(%rbp), %rdi
movq %rdi, -0x210(%rbp)
movl $0x14, %esi
callq 0x34210
movq -0x210(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
movq %rdi, -0x30(%rbp)
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x180d20
movl -0x1c(%rbp), %eax
subl $0x14, %eax
sete %al
movb %al, -0x201(%rbp)
leaq -0x1e1(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x33b0
movq -0x200(%rbp), %rdx
leaq 0x7acc4(%rip), %rsi     # 0x1fb807
leaq -0x1e0(%rbp), %rdi
callq 0x10a90
jmp 0x180b51
movb -0x201(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1c0(%rbp), %rdi
leaq -0x1e0(%rbp), %rdx
callq 0x10f80
jmp 0x180b72
leaq 0x5bc6c(%rip), %rsi     # 0x1dc7e5
leaq -0x1c0(%rbp), %rdi
callq 0x34320
movq %rax, -0x218(%rbp)
jmp 0x180b8e
movq -0x218(%rbp), %rdi
leaq 0x7c079(%rip), %rsi     # 0x1fcc15
callq 0x96ac0
movq %rax, -0x220(%rbp)
jmp 0x180baa
movq -0x220(%rbp), %rdi
leaq 0x5fbf4(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x228(%rbp)
jmp 0x180bc6
movq -0x228(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x343a0
movq %rax, -0x230(%rbp)
jmp 0x180bdf
movq -0x230(%rbp), %rdi
leaq 0x5bbf8(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x238(%rbp)
jmp 0x180bfb
movq -0x238(%rbp), %rdi
leaq 0x5db7f(%rip), %rsi     # 0x1de788
callq 0x34840
movq %rax, -0x240(%rbp)
jmp 0x180c17
movq -0x240(%rbp), %rdi
leaq 0x5fb87(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x248(%rbp)
jmp 0x180c33
movq -0x248(%rbp), %rdi
movl $0x14, -0x1f8(%rbp)
leaq -0x1f8(%rbp), %rsi
callq 0x343a0
movq %rax, -0x250(%rbp)
jmp 0x180c59
movq -0x250(%rbp), %rdi
leaq 0x75814(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x180c6e
leaq -0x1c0(%rbp), %rdi
callq 0x10ff0
jmp 0x180c7c
leaq -0x1e0(%rbp), %rdi
callq 0x3100
leaq -0x1e1(%rbp), %rdi
callq 0x3290
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0x180cf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0x180ce7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x10ff0
jmp 0x180ce5
jmp 0x180ce7
leaq -0x1e0(%rbp), %rdi
callq 0x3100
leaq -0x1e1(%rbp), %rdi
callq 0x3290
movq -0x1f0(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopw %cs:(%rax,%rax)
// File: dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_each_index_2d_body()
TEST(for_each_index_2d) {
  dense_shape<2> s(10, 4);
  s.resolve();
  int expected_flat_offset = 0;
  for_each_index(s, [&](std::tuple<int, int> i) {
    ASSERT_EQ(s[i], expected_flat_offset);
    expected_flat_offset++;
  });
  // Ensure the for_each_index loop above actually ran.
  ASSERT_EQ(expected_flat_offset, 40);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
leaq -0x30(%rbp), %rdi
movq %rdi, -0x228(%rbp)
movl $0xa, %esi
movl $0x4, %edx
callq 0x343e0
movq -0x228(%rbp), %rdi
callq 0x3cca0
movq -0x228(%rbp), %rdi
movl $0x0, -0x34(%rbp)
movq %rdi, -0x48(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x180fb0
movl -0x34(%rbp), %eax
subl $0x28, %eax
sete %al
movb %al, -0x219(%rbp)
leaq -0x1f9(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x33b0
movq -0x218(%rbp), %rdx
leaq 0x7aa61(%rip), %rsi     # 0x1fb835
leaq -0x1f8(%rbp), %rdi
callq 0x10a90
jmp 0x180de2
movb -0x219(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1d8(%rbp), %rdi
leaq -0x1f8(%rbp), %rdx
callq 0x10f80
jmp 0x180e03
leaq 0x5b9db(%rip), %rsi     # 0x1dc7e5
leaq -0x1d8(%rbp), %rdi
callq 0x34320
movq %rax, -0x230(%rbp)
jmp 0x180e1f
movq -0x230(%rbp), %rdi
leaq 0x7bde8(%rip), %rsi     # 0x1fcc15
callq 0x96ac0
movq %rax, -0x238(%rbp)
jmp 0x180e3b
movq -0x238(%rbp), %rdi
leaq 0x5f963(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x240(%rbp)
jmp 0x180e57
movq -0x240(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x343a0
movq %rax, -0x248(%rbp)
jmp 0x180e70
movq -0x248(%rbp), %rdi
leaq 0x5b967(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x250(%rbp)
jmp 0x180e8c
movq -0x250(%rbp), %rdi
leaq 0x6d99c(%rip), %rsi     # 0x1ee836
callq 0x34840
movq %rax, -0x258(%rbp)
jmp 0x180ea8
movq -0x258(%rbp), %rdi
leaq 0x5f8f6(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x260(%rbp)
jmp 0x180ec4
movq -0x260(%rbp), %rdi
movl $0x28, -0x210(%rbp)
leaq -0x210(%rbp), %rsi
callq 0x343a0
movq %rax, -0x268(%rbp)
jmp 0x180eea
movq -0x268(%rbp), %rdi
leaq 0x75583(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x180eff
leaq -0x1d8(%rbp), %rdi
callq 0x10ff0
jmp 0x180f0d
leaq -0x1f8(%rbp), %rdi
callq 0x3100
leaq -0x1f9(%rbp), %rdi
callq 0x3290
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
jmp 0x180f84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
jmp 0x180f78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x10ff0
jmp 0x180f76
jmp 0x180f78
leaq -0x1f8(%rbp), %rdi
callq 0x3100
leaq -0x1f9(%rbp), %rdi
callq 0x3290
movq -0x208(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopw %cs:(%rax,%rax)
// File: dsharlet[P]array/test/shape.cpp
// Function: nda::test_for_each_index_3d_body()
TEST(for_each_index_3d) {
  dense_shape<3> s(3, 5, 8);
  s.resolve();
  int expected_flat_offset = 0;
  move_only token;
  for_each_index(s, [&, token = std::move(token)](auto i) {
    ASSERT_EQ(s[i], expected_flat_offset);
    expected_flat_offset++;
    assert_used(token);
  });
  // Ensure the for_each_index loop above actually ran.
  ASSERT_EQ(expected_flat_offset, 120);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
leaq -0x48(%rbp), %rdi
movq %rdi, -0x248(%rbp)
movl $0x3, %esi
movl $0x5, %edx
movl $0x8, %ecx
callq 0x34640
movq -0x248(%rbp), %rdi
callq 0x11be0
movq -0x248(%rbp), %rdi
movl $0x0, -0x4c(%rbp)
movq %rdi, -0x60(%rbp)
leaq -0x4c(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x181240
movl -0x4c(%rbp), %eax
subl $0x78, %eax
sete %al
movb %al, -0x239(%rbp)
leaq -0x219(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x33b0
movq -0x238(%rbp), %rdx
leaq 0x7a7fa(%rip), %rsi     # 0x1fb863
leaq -0x218(%rbp), %rdi
callq 0x10a90
jmp 0x181077
movb -0x239(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x1f8(%rbp), %rdi
leaq -0x218(%rbp), %rdx
callq 0x10f80
jmp 0x181098
leaq 0x5b746(%rip), %rsi     # 0x1dc7e5
leaq -0x1f8(%rbp), %rdi
callq 0x34320
movq %rax, -0x250(%rbp)
jmp 0x1810b4
movq -0x250(%rbp), %rdi
leaq 0x7bb53(%rip), %rsi     # 0x1fcc15
callq 0x96ac0
movq %rax, -0x258(%rbp)
jmp 0x1810d0
movq -0x258(%rbp), %rdi
leaq 0x5f6ce(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x260(%rbp)
jmp 0x1810ec
movq -0x260(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x343a0
movq %rax, -0x268(%rbp)
jmp 0x181105
movq -0x268(%rbp), %rdi
leaq 0x5b6d2(%rip), %rsi     # 0x1dc7e5
callq 0x34320
movq %rax, -0x270(%rbp)
jmp 0x181121
movq -0x270(%rbp), %rdi
leaq 0x7a74c(%rip), %rsi     # 0x1fb87b
callq 0x356d0
movq %rax, -0x278(%rbp)
jmp 0x18113d
movq -0x278(%rbp), %rdi
leaq 0x5f661(%rip), %rsi     # 0x1e07ac
callq 0x34320
movq %rax, -0x280(%rbp)
jmp 0x181159
movq -0x280(%rbp), %rdi
movl $0x78, -0x230(%rbp)
leaq -0x230(%rbp), %rsi
callq 0x343a0
movq %rax, -0x288(%rbp)
jmp 0x18117f
movq -0x288(%rbp), %rdi
leaq 0x752ee(%rip), %rsi     # 0x1f647b
callq 0x34320
jmp 0x181194
leaq -0x1f8(%rbp), %rdi
callq 0x10ff0
jmp 0x1811a2
leaq -0x218(%rbp), %rdi
callq 0x3100
leaq -0x219(%rbp), %rdi
callq 0x3290
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x181219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x18120d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x10ff0
jmp 0x18120b
jmp 0x18120d
leaq -0x218(%rbp), %rdi
callq 0x3100
leaq -0x219(%rbp), %rdi
callq 0x3290
movq -0x228(%rbp), %rdi
callq 0x33a0
movq %rax, %rdi
callq 0x116d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
movl $0x1, %ecx
callq 0x16d70
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13df0
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
movl $0x1, %ecx
callq 0x10c60
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x97810
leaq -0x60(%rbp), %rdi
movl $0x5, %esi
movl $0xf, %edx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
callq 0x10c60
leaq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x41230
leaq -0x90(%rbp), %rdi
movl $0x5, %esi
movl $0xf, %edx
movl $0x1, %ecx
callq 0x16d70
leaq -0x78(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x98380
leaq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x41230
leaq -0xc0(%rbp), %rdi
movl $0x5, %esi
movl $0xf, %edx
movl $0x1, %ecx
callq 0x16d70
leaq -0xa8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x98380
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
movl $0xa, %edx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
callq 0x10c60
leaq -0x60(%rbp), %rdi
movl $0x3, %esi
movl $0x5, %edx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
callq 0x10c60
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x11310
leaq -0x30(%rbp), %rdi
callq 0x18c570
leaq -0xa8(%rbp), %rdi
movq $-0x1, %rsi
movl $0xa, %edx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
callq 0x10c60
leaq -0xc0(%rbp), %rdi
movl $0x3, %esi
movl $0x5, %edx
movq $-0x1, %rcx
callq 0x10c60
leaq -0x90(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x11310
leaq -0x90(%rbp), %rdi
callq 0x18c570
leaq -0x108(%rbp), %rdi
movq $-0x2, %rsi
movl $0xa, %edx
movl $0x6, %ecx
callq 0x10c60
leaq -0x120(%rbp), %rdi
movl $0x3, %esi
movl $0x5, %edx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
callq 0x10c60
leaq -0xf0(%rbp), %rdi
leaq -0x108(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x11310
leaq -0xf0(%rbp), %rdi
callq 0x18c570
leaq -0x180(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x4, %ecx
movq %rcx, %rdx
callq 0x10c60
leaq -0x198(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x4, %edx
movl $0x2, %ecx
callq 0x10c60
leaq -0x1b0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x4, %edx
movl $0x1, %ecx
callq 0x10c60
leaq -0x168(%rbp), %rdi
leaq -0x180(%rbp), %rsi
leaq -0x198(%rbp), %rdx
leaq -0x1b0(%rbp), %rcx
callq 0x36640
leaq -0x168(%rbp), %rdi
callq 0x18cb00
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq $0x1, -0x8(%rbp)
cmpq $0x64, -0x8(%rbp)
jge 0x1c88f3
movq -0x8(%rbp), %rdx
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13e90
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x1c8450
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x2, %edx
callq 0x1c8450
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x3, %edx
callq 0x1c8450
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl $0x4, %edx
callq 0x1c8450
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl $0x5, %edx
callq 0x1c8450
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x1cb560
cmpq $0x2, -0x8(%rbp)
jl 0x1c8850
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x1cb7f0
cmpq $0x3, -0x8(%rbp)
jl 0x1c8880
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x1cbab0
cmpq $0x4, -0x8(%rbp)
jl 0x1c88b0
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x1cbd90
cmpq $0x5, -0x8(%rbp)
jl 0x1c88e0
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x1cc050
jmp 0x1c88e2
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1c8743
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x102f4(%rip), %rsi     # 0x1e08af
callq 0x3220
movq -0x28(%rbp), %rdi
leaq 0x102e9(%rip), %rsi     # 0x1e08b4
callq 0x3220
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x45770
movq -0x28(%rbp), %rdi
leaq 0xbd55(%rip), %rsi      # 0x1dc36b
callq 0x3220
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dsharlet[P]array/include/array/z_order.h
// Function: void nda::internal::for_each_index_in_z_order<std::tuple<long>, void nda::for_all_indices_in_z_order<std::tuple<long>, nda::test_for_each_in_z_order_1d_body()::$_0>(std::tuple<long> const&, nda::test_for_each_in_z_order_1d_body()::$_0 const&)::'lambda'(std::tuple<long> const&)>(std::tuple<long> const&, nda::test_for_each_in_z_order_1d_body()::$_0 const&)
NDARRAY_UNIQUE void for_each_index_in_z_order(const Extents& extents, const Fn& fn) {
  constexpr index_t Rank = std::tuple_size<Extents>::value;
  // Get the ends of the iteration space as an array.
  const auto end = tuple_to_array<index_t>(extents, make_index_sequence<Rank>());
  const index_t max_extent = *std::max_element(end.begin(), end.end());
  const index_t step = std::max<index_t>(1, next_power_of_two(max_extent) >> 1);
  std::array<index_t, Rank> z = {{0,}};
  for_each_index_in_z_order_impl(end, z, Rank - 1, step, fn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d7a30
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1d7aa0
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1d7ac0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1d7a60
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d7ae0
sarq %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x18a170
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x30e0
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x58(%rbp), %rsi
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x1d4310
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)