int reset(float x[50], int tracker, int n, float arrlower[50]) {
  int i;
  for (i = (tracker + 1); i < n; i++)
    x[i] = arrlower[i];
  return (n - 1);
}


x86 assembly (clang, -O0):
<reset>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    114f <reset+0x4f>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111b <reset+0x1b>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<reset>:
push   %r14
push   %rbx
mov    %edx,%eax
lea    0x1(%rsi),%edx
cmp    %eax,%edx
jge    12b6 <reset+0x1b6>
movslq %edx,%rdx
mov    %eax,%r8d
sub    %esi,%r8d
add    $0xfffffffe,%r8d
cmp    $0x7,%r8d
jb     1245 <reset+0x145>
lea    (%rdi,%rdx,4),%r9
lea    (%r8,%rdx,1),%rsi
lea    (%rcx,%rsi,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%r9
jae    1151 <reset+0x51>
lea    (%rdi,%rsi,4),%rsi
add    $0x4,%rsi
lea    (%rcx,%rdx,4),%rbx
cmp    %rsi,%rbx
jb     1245 <reset+0x145>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rsi
mov    %rsi,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rsi
jae    117f <reset+0x7f>
xor    %esi,%esi
jmp    1200 <reset+0x100>
and    $0xfffffffffffffffc,%r11
lea    (%rdi,%rdx,4),%r14
add    $0x70,%r14
lea    (%rcx,%rdx,4),%rbx
add    $0x70,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%rbx,%rsi,4),%xmm0
movups -0x60(%rbx,%rsi,4),%xmm1
movups %xmm0,-0x70(%r14,%rsi,4)
movups %xmm1,-0x60(%r14,%rsi,4)
movups -0x50(%rbx,%rsi,4),%xmm0
movups -0x40(%rbx,%rsi,4),%xmm1
movups %xmm0,-0x50(%r14,%rsi,4)
movups %xmm1,-0x40(%r14,%rsi,4)
movups -0x30(%rbx,%rsi,4),%xmm0
movups -0x20(%rbx,%rsi,4),%xmm1
movups %xmm0,-0x30(%r14,%rsi,4)
movups %xmm1,-0x20(%r14,%rsi,4)
movups -0x10(%rbx,%rsi,4),%xmm0
movups (%rbx,%rsi,4),%xmm1
movups %xmm0,-0x10(%r14,%rsi,4)
movups %xmm1,(%r14,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%r11
jne    11a0 <reset+0xa0>
test   %r10,%r10
je     123d <reset+0x13d>
add    %rdx,%rsi
lea    (%rdi,%rsi,4),%r11
add    $0x10,%r11
lea    (%rcx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r10
xor    %ebx,%ebx
xchg   %ax,%ax
movups -0x10(%rsi,%rbx,1),%xmm0
movups (%rsi,%rbx,1),%xmm1
movups %xmm0,-0x10(%r11,%rbx,1)
movups %xmm1,(%r11,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1220 <reset+0x120>
cmp    %r9,%r8
je     12b6 <reset+0x1b6>
add    %r9,%rdx
mov    %eax,%ebx
sub    %edx,%ebx
mov    %edx,%esi
not    %esi
add    %eax,%esi
and    $0x3,%ebx
je     1273 <reset+0x173>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffff,%ebx
jne    1260 <reset+0x160>
cmp    $0x3,%esi
jb     12b6 <reset+0x1b6>
mov    %eax,%esi
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rdi,%rdx,4)
movss  0x4(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rdx,4)
movss  0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rdi,%rdx,4)
movss  0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%esi
jne    1280 <reset+0x180>
add    $0xffffffff,%eax
pop    %rbx
pop    %r14
ret

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

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