void leftbig(int *x, int l) {
  int i;
  if (x[0] == 1 && x[1] == 0)
    return;
  for (i = x[0]; i >= 1; i--)
    x[i + l] = x[i];
  for (i = 1; i <= l; i++)
    x[i] = 0;
  x[0] += l;
}


x86 assembly (clang, -O0):
<leftbig>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
cmpl   $0x1,(%rax)
jne    112b <leftbig+0x2b>
mov    -0x8(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jne    112b <leftbig+0x2b>
jmp    11a2 <leftbig+0xa2>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x1,-0x10(%rbp)
jl     1167 <leftbig+0x67>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1134 <leftbig+0x34>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1197 <leftbig+0x97>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    116e <leftbig+0x6e>
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<leftbig>:
push   %rbp
push   %r14
push   %rbx
mov    %esi,%r14d
mov    %rdi,%rbx
mov    (%rdi),%ecx
cmp    $0x1,%rcx
jne    112a <leftbig+0x1a>
cmpl   $0x0,0x4(%rbx)
jne    112e <leftbig+0x1e>
jmp    117c <leftbig+0x6c>
test   %ecx,%ecx
jle    1162 <leftbig+0x52>
movslq %r14d,%r11
cmp    $0x1,%rcx
mov    %rcx,%rdi
adc    $0xffffffffffffffff,%rdi
add    $0x1,%rdi
cmp    $0x8,%rdi
jae    1181 <leftbig+0x71>
add    $0x1,%rcx
lea    (%rbx,%r11,4),%rax
xchg   %ax,%ax
mov    -0x4(%rbx,%rcx,4),%edx
mov    %edx,-0x4(%rax,%rcx,4)
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%rcx
ja     1150 <leftbig+0x40>
test   %r14d,%r14d
jle    1179 <leftbig+0x69>
lea    0x4(%rbx),%rdi
mov    %r14d,%edx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
add    %r14d,(%rbx)
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x1,%rcx
mov    %rcx,%rax
adc    $0xffffffffffffffff,%rax
lea    (%r11,%rcx,1),%r8
mov    $0x4,%edx
mul    %rdx
lea    (%rbx,%r8,4),%rbp
seto   %dl
mov    %rbp,%rsi
sub    %rax,%rsi
cmp    %rbp,%rsi
ja     1146 <leftbig+0x36>
test   %dl,%dl
jne    1146 <leftbig+0x36>
lea    (%rbx,%rcx,4),%rbp
mov    %rbp,%rsi
sub    %rax,%rsi
cmp    %rbp,%rsi
ja     1146 <leftbig+0x36>
test   %dl,%dl
jne    1146 <leftbig+0x36>
xor    %eax,%eax
test   %rcx,%rcx
setne  %al
lea    (%rax,%r11,1),%rdx
lea    (%rbx,%rdx,4),%rdx
lea    (%rbx,%rcx,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jae    11f3 <leftbig+0xe3>
lea    (%rbx,%r8,4),%rdx
add    $0x4,%rdx
lea    (%rbx,%rax,4),%rax
cmp    %rdx,%rax
jb     1146 <leftbig+0x36>
mov    %rdi,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1298 <leftbig+0x188>
mov    %r10,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rbx,%r8,4),%rsi
add    $0xfffffffffffffff4,%rsi
lea    (%rbx,%rcx,4),%rbp
add    $0xfffffffffffffff4,%rbp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x10(%rbp,%rax,4),%xmm0
movups 0x0(%rbp,%rax,4),%xmm1
movups %xmm1,(%rsi,%rax,4)
movups %xmm0,-0x10(%rsi,%rax,4)
movups -0x30(%rbp,%rax,4),%xmm0
movups -0x20(%rbp,%rax,4),%xmm1
movups %xmm1,-0x20(%rsi,%rax,4)
movups %xmm0,-0x30(%rsi,%rax,4)
add    $0xfffffffffffffff0,%rax
add    $0xfffffffffffffffe,%rdx
jne    1230 <leftbig+0x120>
neg    %rax
test   $0x1,%r10b
je     1287 <leftbig+0x177>
mov    %rcx,%rdx
sub    %rax,%rdx
movups -0x1c(%rbx,%rdx,4),%xmm0
movups -0xc(%rbx,%rdx,4),%xmm1
add    %r11,%rdx
movups %xmm1,-0xc(%rbx,%rdx,4)
movups %xmm0,-0x1c(%rbx,%rdx,4)
cmp    %r9,%rdi
je     1162 <leftbig+0x52>
sub    %r9,%rcx
jmp    1146 <leftbig+0x36>
xor    %eax,%eax
test   $0x1,%r10b
jne    126a <leftbig+0x15a>
jmp    1287 <leftbig+0x177>

LLVM IR (-O0):
define void @leftbig(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
store i32* %0, i32** %3
store i32 %1, i32* %4
%6 = load i32*, i32** %3
%7 = getelementptr inbounds i32, i32* %6, i64 0
%8 = load i32, i32* %7
%9 = icmp eq i32 %8, 1
br i1 %9, label %10, label %16
10: ; preds = %2
%11 = load i32*, i32** %3
%12 = getelementptr inbounds i32, i32* %11, i64 1
%13 = load i32, i32* %12
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %16
15: ; preds = %10
br label %57
16: ; preds = %10, %2
%17 = load i32*, i32** %3
%18 = getelementptr inbounds i32, i32* %17, i64 0
%19 = load i32, i32* %18
store i32 %19, i32* %5
br label %20
20: ; preds = %35, %16
%21 = load i32, i32* %5
%22 = icmp sge i32 %21, 1
br i1 %22, label %23, label %38
23: ; preds = %20
%24 = load i32*, i32** %3
%25 = load i32, i32* %5
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %24, i64 %26
%28 = load i32, i32* %27
%29 = load i32*, i32** %3
%30 = load i32, i32* %5
%31 = load i32, i32* %4
%32 = add nsw i32 %30, %31
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i32, i32* %29, i64 %33
store i32 %28, i32* %34
br label %35
35: ; preds = %23
%36 = load i32, i32* %5
%37 = add nsw i32 %36, -1
store i32 %37, i32* %5
br label %20
38: ; preds = %20
store i32 1, i32* %5
br label %39
39: ; preds = %48, %38
%40 = load i32, i32* %5
%41 = load i32, i32* %4
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %51
43: ; preds = %39
%44 = load i32*, i32** %3
%45 = load i32, i32* %5
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
store i32 0, i32* %47
br label %48
48: ; preds = %43
%49 = load i32, i32* %5
%50 = add nsw i32 %49, 1
store i32 %50, i32* %5
br label %39
51: ; preds = %39
%52 = load i32, i32* %4
%53 = load i32*, i32** %3
%54 = getelementptr inbounds i32, i32* %53, i64 0
%55 = load i32, i32* %54
%56 = add nsw i32 %55, %52
store i32 %56, i32* %54
br label %57
57: ; preds = %51, %15
ret void
}

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