void zig_zag_reorder(int block[]) {
  int n, x, y;
  int copy[64];
  for (n = 0; n < 64; n++)
    copy[n] = block[n];
  n = x = y = 0;
  while (n < 63) {
    if (x < 7)
      x++;
    else
      y++;
    block[x + (y * 8)] = copy[++n];
    while (x > 0 && y < 7) {
      x--;
      y++;
      block[x + (y * 8)] = copy[++n];
    }
    if (y < 7)
      y++;
    else
      x++;
    block[x + (y * 8)] = copy[++n];
    while (y > 0 && x < 7) {
      y--;
      x++;
      block[x + (y * 8)] = copy[++n];
    }
  }
}


x86 assembly (clang, -O0):
<zig_zag_reorder>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x40,-0xc(%rbp)
jge    1144 <zig_zag_reorder+0x44>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0xc(%rbp),%rax
mov    %ecx,-0x120(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1116 <zig_zag_reorder+0x16>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x3f,-0xc(%rbp)
jge    12d8 <zig_zag_reorder+0x1d8>
cmpl   $0x7,-0x10(%rbp)
jge    117b <zig_zag_reorder+0x7b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1184 <zig_zag_reorder+0x84>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cltq
mov    -0x120(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
xor    %eax,%eax
cmpl   $0x0,-0x10(%rbp)
mov    %al,-0x121(%rbp)
jle    11ca <zig_zag_reorder+0xca>
cmpl   $0x7,-0x14(%rbp)
setl   %al
mov    %al,-0x121(%rbp)
mov    -0x121(%rbp),%al
test   $0x1,%al
jne    11dd <zig_zag_reorder+0xdd>
jmp    121b <zig_zag_reorder+0x11b>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cltq
mov    -0x120(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11ab <zig_zag_reorder+0xab>
cmpl   $0x7,-0x14(%rbp)
jge    1233 <zig_zag_reorder+0x133>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    123c <zig_zag_reorder+0x13c>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cltq
mov    -0x120(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
xor    %eax,%eax
cmpl   $0x0,-0x14(%rbp)
mov    %al,-0x122(%rbp)
jle    1282 <zig_zag_reorder+0x182>
cmpl   $0x7,-0x10(%rbp)
setl   %al
mov    %al,-0x122(%rbp)
mov    -0x122(%rbp),%al
test   $0x1,%al
jne    1295 <zig_zag_reorder+0x195>
jmp    12d3 <zig_zag_reorder+0x1d3>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
cltq
mov    -0x120(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    -0x14(%rbp),%esi
shl    $0x3,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1263 <zig_zag_reorder+0x163>
jmp    1159 <zig_zag_reorder+0x59>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<zig_zag_reorder>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x100,%rsp
mov    %rdi,%r15
mov    %rsp,%r14
mov    $0x100,%edx
mov    %r14,%rdi
mov    %r15,%rsi
call   1030 <memcpy@plt>
xor    %r9d,%r9d
xor    %r13d,%r13d
xor    %edi,%edi
jmp    1155 <zig_zag_reorder+0x45>
sub    %eax,%r9d
add    %eax,%r10d
add    %eax,%r13d
mov    %r10d,%edi
cmp    $0x3e,%edi
jg     12d7 <zig_zag_reorder+0x1c7>
xor    %r10d,%r10d
xor    %r12d,%r12d
cmp    $0x7,%r13d
setge  %r10b
setl   %r12b
add    %r13d,%r12d
lea    (%r9,%r10,1),%r11d
movslq %edi,%r8
add    $0x1,%edi
mov    0x4(%rsp,%r8,4),%eax
lea    (%r12,%r11,8),%ecx
movslq %ecx,%rcx
mov    %eax,(%r15,%rcx,4)
cmp    $0x7,%r11d
setl   %cl
test   %r12d,%r12d
jle    1223 <zig_zag_reorder+0x113>
cmp    $0x6,%r11d
jg     1223 <zig_zag_reorder+0x113>
xor    %eax,%eax
cmp    $0x7,%r13d
setl   %al
movslq %r9d,%rcx
mov    %r10d,%r11d
add    %rcx,%r11
movslq %r13d,%rdx
lea    (%rdx,%rax,1),%r12
lea    (%r14,%r8,4),%r9
add    $0x8,%r9
add    $0x1,%r8
lea    (%rdx,%rax,1),%r13
add    $0xffffffffffffffff,%r13
add    %r10d,%ecx
lea    0x8(,%rcx,8),%esi
xor    %edx,%edx
xor    %edi,%edi
nopl   0x0(%rax)
lea    (%r12,%rdi,1),%r10
movslq %esi,%rcx
add    %r13,%rcx
lea    (%r11,%rdx,1),%rax
mov    (%r9,%rdx,4),%ebx
add    %rdi,%rcx
mov    %ebx,(%r15,%rcx,4)
cmp    $0x6,%rax
setl   %cl
add    $0xffffffffffffffff,%rdi
cmp    $0x2,%r10
jl     1217 <zig_zag_reorder+0x107>
add    $0x1,%rdx
add    $0x8,%esi
cmp    $0x6,%rax
jl     11e0 <zig_zag_reorder+0xd0>
sub    %edi,%r11d
sub    %edi,%r8d
add    %edi,%r12d
mov    %r8d,%edi
movzbl %cl,%r8d
xor    $0x1,%cl
movzbl %cl,%ebx
lea    (%r12,%rbx,1),%r13d
lea    (%r11,%r8,1),%r9d
movslq %edi,%r10
add    $0x1,%edi
mov    0x4(%rsp,%r10,4),%eax
lea    0x0(%r13,%r9,8),%ecx
movslq %ecx,%rcx
mov    %eax,(%r15,%rcx,4)
test   %r9d,%r9d
jle    114c <zig_zag_reorder+0x3c>
cmp    $0x6,%r13d
jg     114c <zig_zag_reorder+0x3c>
movslq %r11d,%rax
mov    %r8d,%r9d
add    %rax,%r9
movslq %r12d,%rcx
lea    (%rcx,%rbx,1),%r13
lea    (%r14,%r10,4),%r11
add    $0x8,%r11
add    $0x1,%r10
lea    (%rcx,%rbx,1),%rsi
add    $0x1,%rsi
add    %r8d,%eax
lea    -0x8(,%rax,8),%edi
xor    %ecx,%ecx
mov    %r9,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %edi,%rax
add    %rsi,%rax
mov    (%r11,%rcx,4),%edx
add    %rcx,%rax
mov    %edx,(%r15,%rax,4)
lea    0x1(%rcx),%rax
cmp    $0x2,%rbx
jl     1140 <zig_zag_reorder+0x30>
add    %r13,%rcx
add    $0xffffffffffffffff,%rbx
add    $0xfffffff8,%edi
cmp    $0x6,%rcx
mov    %rax,%rcx
jl     12a0 <zig_zag_reorder+0x190>
jmp    1140 <zig_zag_reorder+0x30>
add    $0x100,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @zig_zag_reorder(i32* nocapture %0) {
%2 = bitcast i32* %0 to i8*
%3 = alloca [64 x i32]
%4 = bitcast [64 x i32]* %3 to i8*
br label %14
5: ; preds = %95
%6 = trunc i64 %99 to i32
%7 = trunc i64 %102 to i32
%8 = trunc i64 %101 to i32
br label %9
9: ; preds = %5, %65
%10 = phi i32 [ %75, %65 ], [ %7, %5 ]
%11 = phi i32 [ %72, %65 ], [ %8, %5 ]
%12 = phi i32 [ %74, %65 ], [ %6, %5 ]
%13 = icmp slt i32 %10, 63
br i1 %13, label %14, label %112
14: ; preds = %1, %9
%15 = phi i32 [ %12, %9 ], [ 0, %1 ]
%16 = phi i32 [ %11, %9 ], [ 0, %1 ]
%17 = phi i32 [ %10, %9 ], [ 0, %1 ]
%18 = icmp slt i32 %16, 7
%19 = zext i1 %18 to i32
%20 = add nsw i32 %16, %19
%21 = xor i1 %18, true
%22 = zext i1 %21 to i32
%23 = add nsw i32 %15, %22
%24 = add nsw i32 %17, 1
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %25
%27 = load i32, i32* %26
%28 = shl nsw i32 %23, 3
%29 = add nsw i32 %28, %20
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i32, i32* %0, i64 %30
store i32 %27, i32* %31
%32 = icmp sgt i32 %20, 0
%33 = icmp slt i32 %23, 7
%34 = select i1 %32, i1 %33, i1 false
br i1 %34, label %35, label %65
35: ; preds = %14
%36 = sext i32 %15 to i64
%37 = zext i1 %21 to i64
%38 = add nsw i64 %36, %37
%39 = sext i32 %16 to i64
%40 = zext i1 %18 to i64
%41 = add nsw i64 %39, %40
%42 = sext i32 %17 to i64
%43 = add nsw i64 %42, 1
br label %44
44: ; preds = %35, %44
%45 = phi i64 [ %43, %35 ], [ %51, %44 ]
%46 = phi i64 [ %41, %35 ], [ %48, %44 ]
%47 = phi i64 [ %38, %35 ], [ %49, %44 ]
%48 = add nsw i64 %46, -1
%49 = add nsw i64 %47, 1
%50 = trunc i64 %49 to i32
%51 = add nsw i64 %45, 1
%52 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %51
%53 = load i32, i32* %52
%54 = shl nsw i32 %50, 3
%55 = sext i32 %54 to i64
%56 = add nsw i64 %48, %55
%57 = getelementptr inbounds i32, i32* %0, i64 %56
store i32 %53, i32* %57
%58 = icmp sgt i64 %46, 1
%59 = icmp slt i64 %47, 6
%60 = select i1 %58, i1 %59, i1 false
br i1 %60, label %44, label %61
61: ; preds = %44
%62 = trunc i64 %49 to i32
%63 = trunc i64 %51 to i32
%64 = trunc i64 %48 to i32
br label %65
65: ; preds = %61, %14
%66 = phi i32 [ %24, %14 ], [ %63, %61 ]
%67 = phi i32 [ %20, %14 ], [ %64, %61 ]
%68 = phi i32 [ %23, %14 ], [ %62, %61 ]
%69 = phi i1 [ %33, %14 ], [ %59, %61 ]
%70 = xor i1 %69, true
%71 = zext i1 %70 to i32
%72 = add nsw i32 %67, %71
%73 = zext i1 %69 to i32
%74 = add nsw i32 %68, %73
%75 = add nsw i32 %66, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %76
%78 = load i32, i32* %77
%79 = shl nsw i32 %74, 3
%80 = add nsw i32 %79, %72
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %0, i64 %81
store i32 %78, i32* %82
%83 = icmp sgt i32 %74, 0
%84 = icmp slt i32 %72, 7
%85 = select i1 %83, i1 %84, i1 false
br i1 %85, label %86, label %9
86: ; preds = %65
%87 = sext i32 %68 to i64
%88 = zext i1 %69 to i64
%89 = add nsw i64 %87, %88
%90 = sext i32 %67 to i64
%91 = zext i1 %70 to i64
%92 = add nsw i64 %90, %91
%93 = sext i32 %66 to i64
%94 = add nsw i64 %93, 1
br label %95
95: ; preds = %86, %95
%96 = phi i64 [ %94, %86 ], [ %102, %95 ]
%97 = phi i64 [ %92, %86 ], [ %101, %95 ]
%98 = phi i64 [ %89, %86 ], [ %99, %95 ]
%99 = add nsw i64 %98, -1
%100 = trunc i64 %99 to i32
%101 = add nsw i64 %97, 1
%102 = add nsw i64 %96, 1
%103 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 %102
%104 = load i32, i32* %103
%105 = shl nsw i32 %100, 3
%106 = sext i32 %105 to i64
%107 = add nsw i64 %101, %106
%108 = getelementptr inbounds i32, i32* %0, i64 %107
store i32 %104, i32* %108
%109 = icmp sgt i64 %98, 1
%110 = icmp slt i64 %97, 6
%111 = select i1 %109, i1 %110, i1 false
br i1 %111, label %95, label %5
112: ; preds = %9
ret void
}