void amr_index_to_ijklmn(int pBasis, int nX, int nY, int nZ, int nf, int nq,
                         int index, int *ijklmn) {
  int remainder;
  int two_nf = 2 * nf;
  int qp_1d = pBasis + 1;
  int x_size = (nX + two_nf);
  int y_size = (nY + two_nf);
  int z_size = (nZ + two_nf);
  int xy_stride = x_size * y_size;
  int xyz_stride = xy_stride * z_size;
  int grid_stride = nq * x_size * y_size * z_size;
  int x_stride = grid_stride;
  int y_stride = grid_stride * (qp_1d);
  int z_stride = grid_stride * (qp_1d * qp_1d);
  remainder = index;
  int n = index / z_stride;
  remainder = index % z_stride;
  int m = remainder / y_stride;
  remainder %= y_stride;
  int l = remainder / x_stride;
  remainder %= x_stride;
  remainder %= xyz_stride;
  int k = remainder / xy_stride;
  remainder %= xy_stride;
  int j = remainder / x_size;
  remainder %= x_size;
  int i = remainder;
  ijklmn[0] = i - nf;
  ijklmn[1] = j - nf;
  ijklmn[2] = k - nf;
  ijklmn[3] = l;
  ijklmn[4] = m;
  ijklmn[5] = n;
}


x86 assembly (clang, -O0):
<amr_index_to_ijklmn>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9d,-0x18(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x28(%rbp),%eax
imul   -0x2c(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x24(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    0x10(%rbp),%eax
cltd
idivl  -0x48(%rbp)
mov    %eax,-0x4c(%rbp)
mov    0x10(%rbp),%eax
cltd
idivl  -0x48(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cltd
idivl  -0x44(%rbp)
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x1c(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cltd
idivl  -0x40(%rbp)
mov    %eax,-0x54(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x1c(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cltd
idivl  -0x34(%rbp)
mov    %eax,-0x58(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x1c(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cltd
idivl  -0x28(%rbp)
mov    %eax,-0x5c(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x1c(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%ecx
sub    -0x14(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x5c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x58(%rbp),%ecx
sub    -0x14(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x54(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x50(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x4c(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,0x14(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<amr_index_to_ijklmn>:
push   %rbp
push   %r14
push   %rbx
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%eax
add    $0x1,%edi
lea    (%rsi,%r8,2),%ebx
lea    (%rdx,%r8,2),%ebp
lea    (%rcx,%r8,2),%ecx
imul   %ebx,%ebp
mov    %ebp,%esi
imul   %ecx,%esi
imul   %ecx,%r9d
imul   %ebp,%r9d
mov    %r9d,%ecx
imul   %edi,%ecx
imul   %ecx,%edi
cltd
idiv   %edi
mov    %eax,%r10d
mov    %edx,%eax
cltd
idiv   %ecx
mov    %eax,%r14d
mov    %edx,%eax
cltd
idiv   %r9d
mov    %eax,%edi
mov    %edx,%eax
cltd
idiv   %esi
mov    %edx,%eax
cltd
idiv   %ebp
mov    %eax,%ecx
mov    %edx,%eax
cltd
idiv   %ebx
sub    %r8d,%edx
mov    %edx,(%r11)
sub    %r8d,%eax
mov    %eax,0x4(%r11)
sub    %r8d,%ecx
mov    %ecx,0x8(%r11)
mov    %edi,0xc(%r11)
mov    %r14d,0x10(%r11)
mov    %r10d,0x14(%r11)
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @amr_index_to_ijklmn(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32* %7) {
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
store i32 %0, i32* %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store i32 %6, i32* %15
store i32* %7, i32** %16
%35 = load i32, i32* %13
%36 = mul nsw i32 2, %35
store i32 %36, i32* %18
%37 = load i32, i32* %9
%38 = add nsw i32 %37, 1
store i32 %38, i32* %19
%39 = load i32, i32* %10
%40 = load i32, i32* %18
%41 = add nsw i32 %39, %40
store i32 %41, i32* %20
%42 = load i32, i32* %11
%43 = load i32, i32* %18
%44 = add nsw i32 %42, %43
store i32 %44, i32* %21
%45 = load i32, i32* %12
%46 = load i32, i32* %18
%47 = add nsw i32 %45, %46
store i32 %47, i32* %22
%48 = load i32, i32* %20
%49 = load i32, i32* %21
%50 = mul nsw i32 %48, %49
store i32 %50, i32* %23
%51 = load i32, i32* %23
%52 = load i32, i32* %22
%53 = mul nsw i32 %51, %52
store i32 %53, i32* %24
%54 = load i32, i32* %14
%55 = load i32, i32* %20
%56 = mul nsw i32 %54, %55
%57 = load i32, i32* %21
%58 = mul nsw i32 %56, %57
%59 = load i32, i32* %22
%60 = mul nsw i32 %58, %59
store i32 %60, i32* %25
%61 = load i32, i32* %25
store i32 %61, i32* %26
%62 = load i32, i32* %25
%63 = load i32, i32* %19
%64 = mul nsw i32 %62, %63
store i32 %64, i32* %27
%65 = load i32, i32* %25
%66 = load i32, i32* %19
%67 = load i32, i32* %19
%68 = mul nsw i32 %66, %67
%69 = mul nsw i32 %65, %68
store i32 %69, i32* %28
%70 = load i32, i32* %15
store i32 %70, i32* %17
%71 = load i32, i32* %15
%72 = load i32, i32* %28
%73 = sdiv i32 %71, %72
store i32 %73, i32* %29
%74 = load i32, i32* %15
%75 = load i32, i32* %28
%76 = srem i32 %74, %75
store i32 %76, i32* %17
%77 = load i32, i32* %17
%78 = load i32, i32* %27
%79 = sdiv i32 %77, %78
store i32 %79, i32* %30
%80 = load i32, i32* %27
%81 = load i32, i32* %17
%82 = srem i32 %81, %80
store i32 %82, i32* %17
%83 = load i32, i32* %17
%84 = load i32, i32* %26
%85 = sdiv i32 %83, %84
store i32 %85, i32* %31
%86 = load i32, i32* %26
%87 = load i32, i32* %17
%88 = srem i32 %87, %86
store i32 %88, i32* %17
%89 = load i32, i32* %24
%90 = load i32, i32* %17
%91 = srem i32 %90, %89
store i32 %91, i32* %17
%92 = load i32, i32* %17
%93 = load i32, i32* %23
%94 = sdiv i32 %92, %93
store i32 %94, i32* %32
%95 = load i32, i32* %23
%96 = load i32, i32* %17
%97 = srem i32 %96, %95
store i32 %97, i32* %17
%98 = load i32, i32* %17
%99 = load i32, i32* %20
%100 = sdiv i32 %98, %99
store i32 %100, i32* %33
%101 = load i32, i32* %20
%102 = load i32, i32* %17
%103 = srem i32 %102, %101
store i32 %103, i32* %17
%104 = load i32, i32* %17
store i32 %104, i32* %34
%105 = load i32, i32* %34
%106 = load i32, i32* %13
%107 = sub nsw i32 %105, %106
%108 = load i32*, i32** %16
%109 = getelementptr inbounds i32, i32* %108, i64 0
store i32 %107, i32* %109
%110 = load i32, i32* %33
%111 = load i32, i32* %13
%112 = sub nsw i32 %110, %111
%113 = load i32*, i32** %16
%114 = getelementptr inbounds i32, i32* %113, i64 1
store i32 %112, i32* %114
%115 = load i32, i32* %32
%116 = load i32, i32* %13
%117 = sub nsw i32 %115, %116
%118 = load i32*, i32** %16
%119 = getelementptr inbounds i32, i32* %118, i64 2
store i32 %117, i32* %119
%120 = load i32, i32* %31
%121 = load i32*, i32** %16
%122 = getelementptr inbounds i32, i32* %121, i64 3
store i32 %120, i32* %122
%123 = load i32, i32* %30
%124 = load i32*, i32** %16
%125 = getelementptr inbounds i32, i32* %124, i64 4
store i32 %123, i32* %125
%126 = load i32, i32* %29
%127 = load i32*, i32** %16
%128 = getelementptr inbounds i32, i32* %127, i64 5
store i32 %126, i32* %128
ret void
}

LLVM IR (-O2):
define void @amr_index_to_ijklmn(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32* nocapture writeonly %7) {
%9 = shl nsw i32 %4, 1
%10 = add nsw i32 %0, 1
%11 = add nsw i32 %9, %1
%12 = add nsw i32 %9, %2
%13 = add nsw i32 %9, %3
%14 = mul i32 %11, %12
%15 = mul nsw i32 %14, %13
%16 = mul i32 %14, %5
%17 = mul i32 %16, %13
%18 = mul i32 %17, %10
%19 = mul i32 %18, %10
%20 = sdiv i32 %6, %19
%21 = srem i32 %6, %19
%22 = sdiv i32 %21, %18
%23 = srem i32 %21, %18
%24 = sdiv i32 %23, %17
%25 = srem i32 %23, %17
%26 = srem i32 %25, %15
%27 = sdiv i32 %26, %14
%28 = srem i32 %26, %14
%29 = sdiv i32 %28, %11
%30 = srem i32 %28, %11
%31 = sub nsw i32 %30, %4
store i32 %31, i32* %7
%32 = sub nsw i32 %29, %4
%33 = getelementptr inbounds i32, i32* %7, i64 1
store i32 %32, i32* %33
%34 = sub nsw i32 %27, %4
%35 = getelementptr inbounds i32, i32* %7, i64 2
store i32 %34, i32* %35
%36 = getelementptr inbounds i32, i32* %7, i64 3
store i32 %24, i32* %36
%37 = getelementptr inbounds i32, i32* %7, i64 4
store i32 %22, i32* %37
%38 = getelementptr inbounds i32, i32* %7, i64 5
store i32 %20, i32* %38
ret void
}