#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 */
void rebuild_args(size_t argc, char *argv[], char *subv[]) {
  for (size_t i = 1; i < argc; ++i) {
    subv[i - 1] = argv[i];
  }
}


x86 assembly (clang, -O0):
<rebuild_args>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    1153 <rebuild_args+0x53>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1118 <rebuild_args+0x18>
pop    %rbp
ret

x86 assembly (clang, -O2):
<rebuild_args>:
cmp    $0x2,%rdi
jb     126f <rebuild_args+0x16f>
lea    -0x1(%rdi),%r8
mov    $0x1,%r11d
cmp    $0x4,%r8
jb     1203 <rebuild_args+0x103>
lea    (%rsi,%rdi,8),%rcx
cmp    %rdx,%rcx
jbe    113c <rebuild_args+0x3c>
lea    (%rdx,%rdi,8),%r9
add    $0xfffffffffffffff8,%r9
lea    0x8(%rsi),%rcx
cmp    %r9,%rcx
jb     1203 <rebuild_args+0x103>
mov    %r8,%r11
and    $0xfffffffffffffffc,%r11
lea    -0x4(%r11),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0xc,%rcx
jae    1163 <rebuild_args+0x63>
xor    %ecx,%ecx
jmp    11c9 <rebuild_args+0xc9>
and    $0xfffffffffffffffc,%r10
xor    %ecx,%ecx
nopl   0x0(%rax)
movups 0x8(%rsi,%rcx,8),%xmm0
movups 0x18(%rsi,%rcx,8),%xmm1
movups %xmm0,(%rdx,%rcx,8)
movups %xmm1,0x10(%rdx,%rcx,8)
movups 0x28(%rsi,%rcx,8),%xmm0
movups 0x38(%rsi,%rcx,8),%xmm1
movups %xmm0,0x20(%rdx,%rcx,8)
movups %xmm1,0x30(%rdx,%rcx,8)
movups 0x48(%rsi,%rcx,8),%xmm0
movups 0x58(%rsi,%rcx,8),%xmm1
movups %xmm0,0x40(%rdx,%rcx,8)
movups %xmm1,0x50(%rdx,%rcx,8)
movups 0x68(%rsi,%rcx,8),%xmm0
movups 0x78(%rsi,%rcx,8),%xmm1
movups %xmm0,0x60(%rdx,%rcx,8)
movups %xmm1,0x70(%rdx,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%r10
jne    1170 <rebuild_args+0x70>
test   %r9,%r9
je     11fa <rebuild_args+0xfa>
xchg   %ax,%ax
lea    0x0(,%rcx,8),%r10
or     $0x8,%r10
movups (%rsi,%r10,1),%xmm0
movups 0x10(%rsi,%r10,1),%xmm1
movups %xmm0,(%rdx,%rcx,8)
movups %xmm1,0x10(%rdx,%rcx,8)
add    $0x4,%rcx
add    $0xffffffffffffffff,%r9
jne    11d0 <rebuild_args+0xd0>
cmp    %r11,%r8
je     126f <rebuild_args+0x16f>
or     $0x1,%r11
mov    %edi,%ecx
sub    %r11d,%ecx
mov    %r11,%r8
not    %r8
add    %rdi,%r8
and    $0x3,%rcx
je     1233 <rebuild_args+0x133>
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%r11,8),%rax
mov    %rax,-0x8(%rdx,%r11,8)
add    $0x1,%r11
add    $0xffffffffffffffff,%rcx
jne    1220 <rebuild_args+0x120>
cmp    $0x3,%r8
jb     126f <rebuild_args+0x16f>
nopl   0x0(%rax)
mov    (%rsi,%r11,8),%rax
mov    %rax,-0x8(%rdx,%r11,8)
mov    0x8(%rsi,%r11,8),%rax
mov    %rax,(%rdx,%r11,8)
mov    0x10(%rsi,%r11,8),%rax
mov    %rax,0x8(%rdx,%r11,8)
mov    0x18(%rsi,%r11,8),%rax
mov    %rax,0x10(%rdx,%r11,8)
add    $0x4,%r11
cmp    %r11,%rdi
jne    1240 <rebuild_args+0x140>
ret

LLVM IR (-O0):
define void @rebuild_args(i64 %0, i8** %1, i8** %2) {
%4 = alloca i64
%5 = alloca i8**
%6 = alloca i8**
%7 = alloca i64
store i64 %0, i64* %4
store i8** %1, i8*** %5
store i8** %2, i8*** %6
store i64 1, i64* %7
br label %8
8: ; preds = %21, %3
%9 = load i64, i64* %7
%10 = load i64, i64* %4
%11 = icmp ult i64 %9, %10
br i1 %11, label %12, label %24
12: ; preds = %8
%13 = load i8**, i8*** %5
%14 = load i64, i64* %7
%15 = getelementptr inbounds i8*, i8** %13, i64 %14
%16 = load i8*, i8** %15
%17 = load i8**, i8*** %6
%18 = load i64, i64* %7
%19 = sub i64 %18, 1
%20 = getelementptr inbounds i8*, i8** %17, i64 %19
store i8* %16, i8** %20
br label %21
21: ; preds = %12
%22 = load i64, i64* %7
%23 = add i64 %22, 1
store i64 %23, i64* %7
br label %8
24: ; preds = %8
ret void
}

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