#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ malloc(int);
char **set_argv(int prog_index, int argc, char *argv[]) {
  char **rv;
  int i, j;
  rv = (char **)malloc(sizeof(char *) * (argc - prog_index));
  for (i = prog_index, j = 0; i < argc; ++i, ++j) {
    rv[j] = argv[i];
  }
  return rv;
}


x86 assembly (clang, -O0):
<set_argv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1181 <set_argv+0x71>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1146 <set_argv+0x36>
mov    -0x18(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<set_argv>:
push   %rbp
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %esi,%ebp
mov    %edi,%ebx
mov    %esi,%edi
sub    %ebx,%edi
shl    $0x3,%edi
call   1030 <malloc@plt>
sub    %ebx,%ebp
jle    12c0 <set_argv+0x1b0>
movslq %ebx,%rdx
mov    %ebp,%r9d
cmp    $0x4,%ebp
jb     115c <set_argv+0x4c>
lea    (%rdx,%r9,1),%rcx
lea    (%r14,%rcx,8),%rcx
cmp    %rcx,%rax
jae    11e4 <set_argv+0xd4>
lea    (%rax,%r9,8),%rcx
lea    (%r14,%rdx,8),%rsi
cmp    %rcx,%rsi
jae    11e4 <set_argv+0xd4>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r9,%rdi
mov    %r9,%rcx
and    $0x3,%rcx
je     1186 <set_argv+0x76>
mov    (%r14,%rdx,8),%rbp
mov    %rbp,(%rax,%rsi,8)
add    $0x1,%rdx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    1170 <set_argv+0x60>
cmp    $0x3,%rdi
jb     12c0 <set_argv+0x1b0>
lea    (%r14,%rdx,8),%rcx
add    $0x18,%rcx
sub    %rsi,%r9
lea    (%rax,%rsi,8),%rdx
add    $0x18,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x18(%rcx,%rsi,8),%rdi
mov    %rdi,-0x18(%rdx,%rsi,8)
mov    -0x10(%rcx,%rsi,8),%rdi
mov    %rdi,-0x10(%rdx,%rsi,8)
mov    -0x8(%rcx,%rsi,8),%rdi
mov    %rdi,-0x8(%rdx,%rsi,8)
mov    (%rcx,%rsi,8),%rdi
mov    %rdi,(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    11b0 <set_argv+0xa0>
jmp    12c0 <set_argv+0x1b0>
mov    %r9d,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rcx
jae    120a <set_argv+0xfa>
xor    %ebx,%ebx
jmp    1279 <set_argv+0x169>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%rdx,8),%rbp
add    $0x70,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rbp,%rbx,8),%xmm0
movups -0x60(%rbp,%rbx,8),%xmm1
movups %xmm0,(%rax,%rbx,8)
movups %xmm1,0x10(%rax,%rbx,8)
movups -0x50(%rbp,%rbx,8),%xmm0
movups -0x40(%rbp,%rbx,8),%xmm1
movups %xmm0,0x20(%rax,%rbx,8)
movups %xmm1,0x30(%rax,%rbx,8)
movups -0x30(%rbp,%rbx,8),%xmm0
movups -0x20(%rbp,%rbx,8),%xmm1
movups %xmm0,0x40(%rax,%rbx,8)
movups %xmm1,0x50(%rax,%rbx,8)
movups -0x10(%rbp,%rbx,8),%xmm0
movups 0x0(%rbp,%rbx,8),%xmm1
movups %xmm0,0x60(%rax,%rbx,8)
movups %xmm1,0x70(%rax,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1220 <set_argv+0x110>
test   %r8,%r8
je     12bb <set_argv+0x1ab>
lea    (%rax,%rbx,8),%rcx
add    $0x10,%rcx
add    %rdx,%rbx
lea    (%r14,%rbx,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    12a0 <set_argv+0x190>
cmp    %r9,%rsi
jne    12c5 <set_argv+0x1b5>
pop    %rbx
pop    %r14
pop    %rbp
ret
add    %rsi,%rdx
jmp    115e <set_argv+0x4e>

LLVM IR (-O0):
define i8** @set_argv(i32 %0, i32 %1, i8** %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i8**
%7 = alloca i8**
%8 = alloca i32
%9 = alloca i32
store i32 %0, i32* %4
store i32 %1, i32* %5
store i8** %2, i8*** %6
%10 = load i32, i32* %5
%11 = load i32, i32* %4
%12 = sub nsw i32 %10, %11
%13 = sext i32 %12 to i64
%14 = mul i64 8, %13
%15 = trunc i64 %14 to i32
%16 = call i64 @malloc(i32 %15)
%17 = inttoptr i64 %16 to i8**
store i8** %17, i8*** %7
%18 = load i32, i32* %4
store i32 %18, i32* %8
store i32 0, i32* %9
br label %19
19: ; preds = %33, %3
%20 = load i32, i32* %8
%21 = load i32, i32* %5
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %38
23: ; preds = %19
%24 = load i8**, i8*** %6
%25 = load i32, i32* %8
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i8*, i8** %24, i64 %26
%28 = load i8*, i8** %27
%29 = load i8**, i8*** %7
%30 = load i32, i32* %9
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8*, i8** %29, i64 %31
store i8* %28, i8** %32
br label %33
33: ; preds = %23
%34 = load i32, i32* %8
%35 = add nsw i32 %34, 1
store i32 %35, i32* %8
%36 = load i32, i32* %9
%37 = add nsw i32 %36, 1
store i32 %37, i32* %9
br label %19
38: ; preds = %19
%39 = load i8**, i8*** %7
ret i8** %39
}

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