void initTableOrder(int arr[][2], int size, int val) {
  int index;
  for (index = 0; index < size; index++)
    arr[index][0] = arr[index][1] = val;
}


x86 assembly (clang, -O0):
<initTableOrder>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1149 <initTableOrder+0x49>
mov    -0x10(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,0x4(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1115 <initTableOrder+0x15>
pop    %rbp
ret

x86 assembly (clang, -O2):
<initTableOrder>:
test   %esi,%esi
jle    11d0 <initTableOrder+0xd0>
mov    %esi,%r8d
cmp    $0x4,%esi
jae    1117 <initTableOrder+0x17>
xor    %ecx,%ecx
jmp    11c0 <initTableOrder+0xc0>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
movd   %edx,%xmm0
lea    -0x4(%rcx),%rax
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%r9d
and    $0x3,%r9d
pshufd $0x0,%xmm0,%xmm0
cmp    $0xc,%rax
jae    1146 <initTableOrder+0x46>
xor    %eax,%eax
jmp    1189 <initTableOrder+0x89>
and    $0xfffffffffffffffc,%rsi
xor    %eax,%eax
nopl   0x0(%rax)
movdqu %xmm0,(%rdi,%rax,8)
movdqu %xmm0,0x10(%rdi,%rax,8)
movdqu %xmm0,0x20(%rdi,%rax,8)
movdqu %xmm0,0x30(%rdi,%rax,8)
movdqu %xmm0,0x40(%rdi,%rax,8)
movdqu %xmm0,0x50(%rdi,%rax,8)
movdqu %xmm0,0x60(%rdi,%rax,8)
movdqu %xmm0,0x70(%rdi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rsi
jne    1150 <initTableOrder+0x50>
test   %r9,%r9
je     11b0 <initTableOrder+0xb0>
xchg   %ax,%ax
lea    0x0(,%rax,8),%rsi
or     $0x10,%rsi
movdqu %xmm0,(%rdi,%rax,8)
movdqu %xmm0,(%rdi,%rsi,1)
add    $0x4,%rax
add    $0xffffffffffffffff,%r9
jne    1190 <initTableOrder+0x90>
cmp    %r8,%rcx
je     11d0 <initTableOrder+0xd0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edx,0x4(%rdi,%rcx,8)
mov    %edx,(%rdi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    11c0 <initTableOrder+0xc0>
ret

LLVM IR (-O0):
define void @initTableOrder([2 x i32]* %0, i32 %1, i32 %2) {
%4 = alloca [2 x i32]*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store [2 x i32]* %0, [2 x i32]** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store i32 0, i32* %7
br label %8
8: ; preds = %24, %3
%9 = load i32, i32* %7
%10 = load i32, i32* %5
%11 = icmp slt i32 %9, %10
br i1 %11, label %12, label %27
12: ; preds = %8
%13 = load i32, i32* %6
%14 = load [2 x i32]*, [2 x i32]** %4
%15 = load i32, i32* %7
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds [2 x i32], [2 x i32]* %14, i64 %16
%18 = getelementptr inbounds [2 x i32], [2 x i32]* %17, i64 0, i64 1
store i32 %13, i32* %18
%19 = load [2 x i32]*, [2 x i32]** %4
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [2 x i32], [2 x i32]* %19, i64 %21
%23 = getelementptr inbounds [2 x i32], [2 x i32]* %22, i64 0, i64 0
store i32 %13, i32* %23
br label %24
24: ; preds = %12
%25 = load i32, i32* %7
%26 = add nsw i32 %25, 1
store i32 %26, i32* %7
br label %8
27: ; preds = %8
ret void
}

LLVM IR (-O2):
define void @initTableOrder([2 x i32]* nocapture writeonly %0, i32 %1, i32 %2) {
%4 = icmp sgt i32 %1, 0
br i1 %4, label %5, label %83
5: ; preds = %3
%6 = zext i32 %1 to i64
%7 = icmp ult i32 %1, 4
br i1 %7, label %75, label %8
8: ; preds = %5
%9 = and i64 %6, 4294967292
%10 = insertelement <2 x i32> poison, i32 %2, i64 0
%11 = insertelement <2 x i32> poison, i32 %2, i64 0
%12 = add nsw i64 %9, -4
%13 = lshr exact i64 %12, 2
%14 = add nuw nsw i64 %13, 1
%15 = and i64 %14, 3
%16 = icmp ult i64 %12, 12
br i1 %16, label %56, label %17
17: ; preds = %8
%18 = and i64 %14, 9223372036854775804
%19 = shufflevector <2 x i32> %10, <2 x i32> poison, <4 x i32> zeroinitializer
%20 = shufflevector <2 x i32> %11, <2 x i32> poison, <4 x i32> zeroinitializer
%21 = shufflevector <2 x i32> %10, <2 x i32> poison, <4 x i32> zeroinitializer
%22 = shufflevector <2 x i32> %11, <2 x i32> poison, <4 x i32> zeroinitializer
%23 = shufflevector <2 x i32> %10, <2 x i32> poison, <4 x i32> zeroinitializer
%24 = shufflevector <2 x i32> %11, <2 x i32> poison, <4 x i32> zeroinitializer
%25 = shufflevector <2 x i32> %10, <2 x i32> poison, <4 x i32> zeroinitializer
%26 = shufflevector <2 x i32> %11, <2 x i32> poison, <4 x i32> zeroinitializer
br label %27
27: ; preds = %27, %17
%28 = phi i64 [ 0, %17 ], [ %53, %27 ]
%29 = phi i64 [ 0, %17 ], [ %54, %27 ]
%30 = or i64 %28, 2
%31 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %28, i64 0
%32 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %30, i64 0
%33 = bitcast i32* %31 to <4 x i32>*
%34 = bitcast i32* %32 to <4 x i32>*
store <4 x i32> %19, <4 x i32>* %33
store <4 x i32> %20, <4 x i32>* %34
%35 = or i64 %28, 4
%36 = or i64 %28, 6
%37 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %35, i64 0
%38 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %36, i64 0
%39 = bitcast i32* %37 to <4 x i32>*
%40 = bitcast i32* %38 to <4 x i32>*
store <4 x i32> %21, <4 x i32>* %39
store <4 x i32> %22, <4 x i32>* %40
%41 = or i64 %28, 8
%42 = or i64 %28, 10
%43 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %41, i64 0
%44 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %42, i64 0
%45 = bitcast i32* %43 to <4 x i32>*
%46 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %23, <4 x i32>* %45
store <4 x i32> %24, <4 x i32>* %46
%47 = or i64 %28, 12
%48 = or i64 %28, 14
%49 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %47, i64 0
%50 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %48, i64 0
%51 = bitcast i32* %49 to <4 x i32>*
%52 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %25, <4 x i32>* %51
store <4 x i32> %26, <4 x i32>* %52
%53 = add nuw i64 %28, 16
%54 = add nuw i64 %29, 4
%55 = icmp eq i64 %54, %18
br i1 %55, label %56, label %27
56: ; preds = %27, %8
%57 = phi i64 [ 0, %8 ], [ %53, %27 ]
%58 = icmp eq i64 %15, 0
br i1 %58, label %73, label %59
59: ; preds = %56
%60 = shufflevector <2 x i32> %10, <2 x i32> poison, <4 x i32> zeroinitializer
%61 = shufflevector <2 x i32> %11, <2 x i32> poison, <4 x i32> zeroinitializer
br label %62
62: ; preds = %62, %59
%63 = phi i64 [ %57, %59 ], [ %70, %62 ]
%64 = phi i64 [ 0, %59 ], [ %71, %62 ]
%65 = or i64 %63, 2
%66 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %63, i64 0
%67 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %65, i64 0
%68 = bitcast i32* %66 to <4 x i32>*
%69 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %60, <4 x i32>* %68
store <4 x i32> %61, <4 x i32>* %69
%70 = add nuw i64 %63, 4
%71 = add i64 %64, 1
%72 = icmp eq i64 %71, %15
br i1 %72, label %73, label %62
73: ; preds = %62, %56
%74 = icmp eq i64 %9, %6
br i1 %74, label %83, label %75
75: ; preds = %5, %73
%76 = phi i64 [ 0, %5 ], [ %9, %73 ]
br label %77
77: ; preds = %75, %77
%78 = phi i64 [ %81, %77 ], [ %76, %75 ]
%79 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %78, i64 1
store i32 %2, i32* %79
%80 = getelementptr inbounds [2 x i32], [2 x i32]* %0, i64 %78, i64 0
store i32 %2, i32* %80
%81 = add nuw nsw i64 %78, 1
%82 = icmp eq i64 %81, %6
br i1 %82, label %83, label %77
83: ; preds = %77, %73, %3
ret void
}