void permutation_set_permutation_array(int *permutation_array, int *value_array,
                                       int N) {
  int x;
  static int y = 0;
  int row;
  row = N * y;
  for (x = 0; x < N; x++) {
    permutation_array[row + x] = value_array[x];
  }
  y++;
}


x86 assembly (clang, -O0):
<permutation_set_permutation_array>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
imul   0x2f0b(%rip),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1158 <permutation_set_permutation_array+0x58>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1123 <permutation_set_permutation_array+0x23>
mov    0x2ec6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2ebd(%rip)
pop    %rbp
ret

x86 assembly (clang, -O2):
<permutation_set_permutation_array>:
push   %rbx
mov    0x2f1c(%rip),%r9d
test   %edx,%edx
jle    1294 <permutation_set_permutation_array+0x194>
mov    %r9d,%eax
imul   %edx,%eax
movslq %eax,%r8
mov    %edx,%r11d
cmp    $0x8,%edx
jb     1143 <permutation_set_permutation_array+0x43>
lea    (%rdi,%r8,4),%rax
lea    (%rsi,%r11,4),%rcx
cmp    %rcx,%rax
jae    11bc <permutation_set_permutation_array+0xbc>
lea    (%r8,%r11,1),%rax
lea    (%rdi,%rax,4),%rax
cmp    %rsi,%rax
jbe    11bc <permutation_set_permutation_array+0xbc>
xor    %edx,%edx
mov    %rdx,%r10
not    %r10
add    %r11,%r10
mov    %r11,%rcx
and    $0x3,%rcx
je     1170 <permutation_set_permutation_array+0x70>
lea    (%rdi,%r8,4),%rbx
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rdx,4),%eax
mov    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1160 <permutation_set_permutation_array+0x60>
cmp    $0x3,%r10
jb     1294 <permutation_set_permutation_array+0x194>
lea    (%rdi,%r8,4),%rax
add    $0xc,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rdx,4),%ecx
mov    %ecx,-0xc(%rax,%rdx,4)
mov    0x4(%rsi,%rdx,4),%ecx
mov    %ecx,-0x8(%rax,%rdx,4)
mov    0x8(%rsi,%rdx,4),%ecx
mov    %ecx,-0x4(%rax,%rdx,4)
mov    0xc(%rsi,%rdx,4),%ecx
mov    %ecx,(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    1190 <permutation_set_permutation_array+0x90>
jmp    1294 <permutation_set_permutation_array+0x194>
mov    %r11d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    11e2 <permutation_set_permutation_array+0xe2>
xor    %ecx,%ecx
jmp    1248 <permutation_set_permutation_array+0x148>
and    $0xfffffffffffffffc,%rax
lea    (%rdi,%r8,4),%rbx
add    $0x70,%rbx
xor    %ecx,%ecx
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
movups %xmm0,-0x70(%rbx,%rcx,4)
movups %xmm1,-0x60(%rbx,%rcx,4)
movups 0x20(%rsi,%rcx,4),%xmm0
movups 0x30(%rsi,%rcx,4),%xmm1
movups %xmm0,-0x50(%rbx,%rcx,4)
movups %xmm1,-0x40(%rbx,%rcx,4)
movups 0x40(%rsi,%rcx,4),%xmm0
movups 0x50(%rsi,%rcx,4),%xmm1
movups %xmm0,-0x30(%rbx,%rcx,4)
movups %xmm1,-0x20(%rbx,%rcx,4)
movups 0x60(%rsi,%rcx,4),%xmm0
movups 0x70(%rsi,%rcx,4),%xmm1
movups %xmm0,-0x10(%rbx,%rcx,4)
movups %xmm1,(%rbx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rax
jne    11f0 <permutation_set_permutation_array+0xf0>
test   %r10,%r10
je     128b <permutation_set_permutation_array+0x18b>
lea    (%rcx,%r8,1),%rax
lea    (%rdi,%rax,4),%rax
add    $0x10,%rax
lea    (%rsi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rax,%rbx,1)
movups %xmm1,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1270 <permutation_set_permutation_array+0x170>
cmp    %r11,%rdx
jne    1145 <permutation_set_permutation_array+0x45>
add    $0x1,%r9d
mov    %r9d,0x2d85(%rip)
pop    %rbx
ret

LLVM IR (-O0):
@permutation_set_permutation_array.y = internal global i32 0
define void @permutation_set_permutation_array(i32* %0, i32* %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
%9 = load i32, i32* %6
%10 = load i32, i32* @permutation_set_permutation_array.y
%11 = mul nsw i32 %9, %10
store i32 %11, i32* %8
store i32 0, i32* %7
br label %12
12: ; preds = %28, %3
%13 = load i32, i32* %7
%14 = load i32, i32* %6
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %31
16: ; preds = %12
%17 = load i32*, i32** %5
%18 = load i32, i32* %7
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i32, i32* %17, i64 %19
%21 = load i32, i32* %20
%22 = load i32*, i32** %4
%23 = load i32, i32* %8
%24 = load i32, i32* %7
%25 = add nsw i32 %23, %24
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %22, i64 %26
store i32 %21, i32* %27
br label %28
28: ; preds = %16
%29 = load i32, i32* %7
%30 = add nsw i32 %29, 1
store i32 %30, i32* %7
br label %12
31: ; preds = %12
%32 = load i32, i32* @permutation_set_permutation_array.y
%33 = add nsw i32 %32, 1
store i32 %33, i32* @permutation_set_permutation_array.y
ret void
}

LLVM IR (-O2):
@permutation_set_permutation_array.y = internal unnamed_addr global i32 0
define void @permutation_set_permutation_array(i32* nocapture writeonly %0, i32* nocapture %1, i32 %2) {
%4 = load i32, i32* @permutation_set_permutation_array.y
%5 = icmp sgt i32 %2, 0
br i1 %5, label %6, label %145
6: ; preds = %3
%7 = mul i32 %4, %2
%8 = sext i32 %7 to i64
%9 = zext i32 %2 to i64
%10 = icmp ult i32 %2, 8
br i1 %10, label %103, label %11
11: ; preds = %6
%12 = getelementptr i32, i32* %0, i64 %8
%13 = add nsw i64 %8, %9
%14 = getelementptr i32, i32* %0, i64 %13
%15 = getelementptr i32, i32* %1, i64 %9
%16 = icmp ult i32* %12, %15
%17 = icmp ugt i32* %14, %1
%18 = and i1 %16, %17
br i1 %18, label %103, label %19
19: ; preds = %11
%20 = and i64 %9, 4294967288
%21 = add nsw i64 %20, -8
%22 = lshr exact i64 %21, 3
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 3
%25 = icmp ult i64 %21, 24
br i1 %25, label %81, label %26
26: ; preds = %19
%27 = and i64 %23, 4611686018427387900
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %78, %28 ]
%30 = phi i64 [ 0, %26 ], [ %79, %28 ]
%31 = getelementptr inbounds i32, i32* %1, i64 %29
%32 = bitcast i32* %31 to <4 x i32>*
%33 = load <4 x i32>, <4 x i32>* %32
%34 = getelementptr inbounds i32, i32* %31, i64 4
%35 = bitcast i32* %34 to <4 x i32>*
%36 = load <4 x i32>, <4 x i32>* %35
%37 = add nsw i64 %29, %8
%38 = getelementptr inbounds i32, i32* %0, i64 %37
%39 = bitcast i32* %38 to <4 x i32>*
store <4 x i32> %33, <4 x i32>* %39
%40 = getelementptr inbounds i32, i32* %38, i64 4
%41 = bitcast i32* %40 to <4 x i32>*
store <4 x i32> %36, <4 x i32>* %41
%42 = or i64 %29, 8
%43 = getelementptr inbounds i32, i32* %1, i64 %42
%44 = bitcast i32* %43 to <4 x i32>*
%45 = load <4 x i32>, <4 x i32>* %44
%46 = getelementptr inbounds i32, i32* %43, i64 4
%47 = bitcast i32* %46 to <4 x i32>*
%48 = load <4 x i32>, <4 x i32>* %47
%49 = add nsw i64 %42, %8
%50 = getelementptr inbounds i32, i32* %0, i64 %49
%51 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %51
%52 = getelementptr inbounds i32, i32* %50, i64 4
%53 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %53
%54 = or i64 %29, 16
%55 = getelementptr inbounds i32, i32* %1, i64 %54
%56 = bitcast i32* %55 to <4 x i32>*
%57 = load <4 x i32>, <4 x i32>* %56
%58 = getelementptr inbounds i32, i32* %55, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
%60 = load <4 x i32>, <4 x i32>* %59
%61 = add nsw i64 %54, %8
%62 = getelementptr inbounds i32, i32* %0, i64 %61
%63 = bitcast i32* %62 to <4 x i32>*
store <4 x i32> %57, <4 x i32>* %63
%64 = getelementptr inbounds i32, i32* %62, i64 4
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> %60, <4 x i32>* %65
%66 = or i64 %29, 24
%67 = getelementptr inbounds i32, i32* %1, i64 %66
%68 = bitcast i32* %67 to <4 x i32>*
%69 = load <4 x i32>, <4 x i32>* %68
%70 = getelementptr inbounds i32, i32* %67, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
%72 = load <4 x i32>, <4 x i32>* %71
%73 = add nsw i64 %66, %8
%74 = getelementptr inbounds i32, i32* %0, i64 %73
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> %69, <4 x i32>* %75
%76 = getelementptr inbounds i32, i32* %74, i64 4
%77 = bitcast i32* %76 to <4 x i32>*
store <4 x i32> %72, <4 x i32>* %77
%78 = add nuw i64 %29, 32
%79 = add i64 %30, 4
%80 = icmp eq i64 %79, %27
br i1 %80, label %81, label %28
81: ; preds = %28, %19
%82 = phi i64 [ 0, %19 ], [ %78, %28 ]
%83 = icmp eq i64 %24, 0
br i1 %83, label %101, label %84
84: ; preds = %81, %84
%85 = phi i64 [ %98, %84 ], [ %82, %81 ]
%86 = phi i64 [ %99, %84 ], [ 0, %81 ]
%87 = getelementptr inbounds i32, i32* %1, i64 %85
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = getelementptr inbounds i32, i32* %87, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = add nsw i64 %85, %8
%94 = getelementptr inbounds i32, i32* %0, i64 %93
%95 = bitcast i32* %94 to <4 x i32>*
store <4 x i32> %89, <4 x i32>* %95
%96 = getelementptr inbounds i32, i32* %94, i64 4
%97 = bitcast i32* %96 to <4 x i32>*
store <4 x i32> %92, <4 x i32>* %97
%98 = add nuw i64 %85, 8
%99 = add i64 %86, 1
%100 = icmp eq i64 %99, %24
br i1 %100, label %101, label %84
101: ; preds = %84, %81
%102 = icmp eq i64 %20, %9
br i1 %102, label %145, label %103
103: ; preds = %11, %6, %101
%104 = phi i64 [ 0, %11 ], [ 0, %6 ], [ %20, %101 ]
%105 = xor i64 %104, -1
%106 = add nsw i64 %105, %9
%107 = and i64 %9, 3
%108 = icmp eq i64 %107, 0
br i1 %108, label %119, label %109
109: ; preds = %103, %109
%110 = phi i64 [ %116, %109 ], [ %104, %103 ]
%111 = phi i64 [ %117, %109 ], [ 0, %103 ]
%112 = getelementptr inbounds i32, i32* %1, i64 %110
%113 = load i32, i32* %112
%114 = add nsw i64 %110, %8
%115 = getelementptr inbounds i32, i32* %0, i64 %114
store i32 %113, i32* %115
%116 = add nuw nsw i64 %110, 1
%117 = add i64 %111, 1
%118 = icmp eq i64 %117, %107
br i1 %118, label %119, label %109
119: ; preds = %109, %103
%120 = phi i64 [ %104, %103 ], [ %116, %109 ]
%121 = icmp ult i64 %106, 3
br i1 %121, label %145, label %122
122: ; preds = %119, %122
%123 = phi i64 [ %143, %122 ], [ %120, %119 ]
%124 = getelementptr inbounds i32, i32* %1, i64 %123
%125 = load i32, i32* %124
%126 = add nsw i64 %123, %8
%127 = getelementptr inbounds i32, i32* %0, i64 %126
store i32 %125, i32* %127
%128 = add nuw nsw i64 %123, 1
%129 = getelementptr inbounds i32, i32* %1, i64 %128
%130 = load i32, i32* %129
%131 = add nsw i64 %128, %8
%132 = getelementptr inbounds i32, i32* %0, i64 %131
store i32 %130, i32* %132
%133 = add nuw nsw i64 %123, 2
%134 = getelementptr inbounds i32, i32* %1, i64 %133
%135 = load i32, i32* %134
%136 = add nsw i64 %133, %8
%137 = getelementptr inbounds i32, i32* %0, i64 %136
store i32 %135, i32* %137
%138 = add nuw nsw i64 %123, 3
%139 = getelementptr inbounds i32, i32* %1, i64 %138
%140 = load i32, i32* %139
%141 = add nsw i64 %138, %8
%142 = getelementptr inbounds i32, i32* %0, i64 %141
store i32 %140, i32* %142
%143 = add nuw nsw i64 %123, 4
%144 = icmp eq i64 %143, %9
br i1 %144, label %145, label %122
145: ; preds = %119, %122, %101, %3
%146 = add nsw i32 %4, 1
store i32 %146, i32* @permutation_set_permutation_array.y
ret void
}