#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 */
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ dup(int);
int /*<<< orphan*/ errno;
int /*<<< orphan*/ execvp(char *, char **);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ stderr;
char *strerror(int /*<<< orphan*/);
char **xcalloc(int, int);
int sd_exec(int argc, char **argv, int in, int out, int err) {
  char **my_argv;
  int i;
  if (argc == 0)
    return 0;
  if (in != 0) {
    close(0);
    dup(in);
  }
  if (out != 1) {
    close(1);
    dup(out);
  }
  if (err != 2 && err != out) {
    close(2);
    dup(err);
  }
  my_argv = xcalloc(argc + 1, sizeof(char *));
  for (i = 0; i < argc; i++)
    my_argv[i] = argv[i];
  my_argv[i] = NULL;
  execvp(my_argv[0], my_argv);
  fprintf(stderr, "exec: %s\n", strerror(errno));
  return 1;
}


x86 assembly (clang, -O0):
<sd_exec>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
cmpl   $0x0,-0x8(%rbp)
jne    118f <sd_exec+0x2f>
movl   $0x0,-0x4(%rbp)
jmp    128c <sd_exec+0x12c>
cmpl   $0x0,-0x14(%rbp)
je     11a8 <sd_exec+0x48>
xor    %edi,%edi
call   1040 <close@plt>
mov    -0x14(%rbp),%edi
call   1030 <dup@plt>
cmpl   $0x1,-0x18(%rbp)
je     11c4 <sd_exec+0x64>
mov    $0x1,%edi
call   1040 <close@plt>
mov    -0x18(%rbp),%edi
call   1030 <dup@plt>
cmpl   $0x2,-0x1c(%rbp)
je     11ec <sd_exec+0x8c>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     11ec <sd_exec+0x8c>
mov    $0x2,%edi
call   1040 <close@plt>
mov    -0x1c(%rbp),%edi
call   1030 <dup@plt>
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
call   1080 <xcalloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1239 <sd_exec+0xd9>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1207 <sd_exec+0xa7>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    (%rax),%rdi
mov    -0x28(%rbp),%rsi
call   1060 <execvp@plt>
mov    0x2d80(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    0x2d6c(%rip),%rax
mov    (%rax),%edi
call   1070 <strerror@plt>
mov    -0x30(%rbp),%edi
mov    %rax,%rdx
lea    0xd80(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sd_exec>:
test   %edi,%edi
je     1271 <sd_exec+0x111>
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r8d,%r15d
mov    %ecx,%r12d
mov    %edx,%ebp
mov    %rsi,%rbx
mov    %edi,%r14d
test   %edx,%edx
je     1190 <sd_exec+0x30>
xor    %edi,%edi
call   1040 <close@plt>
mov    %ebp,%edi
call   1030 <dup@plt>
cmp    $0x1,%r12d
je     11a8 <sd_exec+0x48>
mov    $0x1,%edi
call   1040 <close@plt>
mov    %r12d,%edi
call   1030 <dup@plt>
cmp    $0x2,%r15d
je     11c5 <sd_exec+0x65>
cmp    %r12d,%r15d
je     11c5 <sd_exec+0x65>
mov    $0x2,%edi
call   1040 <close@plt>
mov    %r15d,%edi
call   1030 <dup@plt>
lea    0x1(%r14),%edi
mov    $0x8,%esi
call   1080 <xcalloc@plt>
test   %r14d,%r14d
jle    1274 <sd_exec+0x114>
mov    %r14d,%ecx
cmp    $0x4,%r14d
jb     11ff <sd_exec+0x9f>
lea    (%rbx,%rcx,8),%rdx
cmp    %rdx,%rax
jae    12bf <sd_exec+0x15f>
lea    (%rax,%rcx,8),%rdx
cmp    %rbx,%rdx
jbe    12bf <sd_exec+0x15f>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rdi
and    $0x3,%rdi
je     1232 <sd_exec+0xd2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rdx,8),%rbp
mov    %rbp,(%rax,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1220 <sd_exec+0xc0>
cmp    $0x3,%rsi
jb     1276 <sd_exec+0x116>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,8),%rsi
mov    %rsi,(%rax,%rdx,8)
mov    0x8(%rbx,%rdx,8),%rsi
mov    %rsi,0x8(%rax,%rdx,8)
mov    0x10(%rbx,%rdx,8),%rsi
mov    %rsi,0x10(%rax,%rdx,8)
mov    0x18(%rbx,%rdx,8),%rsi
mov    %rsi,0x18(%rax,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1240 <sd_exec+0xe0>
jmp    1276 <sd_exec+0x116>
xor    %eax,%eax
ret
xor    %ecx,%ecx
movq   $0x0,(%rax,%rcx,8)
mov    (%rax),%rdi
mov    %rax,%rsi
call   1060 <execvp@plt>
mov    0x2d50(%rip),%rax
mov    (%rax),%ebx
mov    0x2d3f(%rip),%rax
mov    (%rax),%edi
call   1070 <strerror@plt>
lea    0xd59(%rip),%rsi
mov    %ebx,%edi
mov    %rax,%rdx
call   1050 <fprintf@plt>
mov    $0x1,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ecx,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rsi
jae    12e4 <sd_exec+0x184>
xor    %ebp,%ebp
jmp    1348 <sd_exec+0x1e8>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rbp,8),%xmm0
movups 0x10(%rbx,%rbp,8),%xmm1
movups %xmm0,(%rax,%rbp,8)
movups %xmm1,0x10(%rax,%rbp,8)
movups 0x20(%rbx,%rbp,8),%xmm0
movups 0x30(%rbx,%rbp,8),%xmm1
movups %xmm0,0x20(%rax,%rbp,8)
movups %xmm1,0x30(%rax,%rbp,8)
movups 0x40(%rbx,%rbp,8),%xmm0
movups 0x50(%rbx,%rbp,8),%xmm1
movups %xmm0,0x40(%rax,%rbp,8)
movups %xmm1,0x50(%rax,%rbp,8)
movups 0x60(%rbx,%rbp,8),%xmm0
movups 0x70(%rbx,%rbp,8),%xmm1
movups %xmm0,0x60(%rax,%rbp,8)
movups %xmm1,0x70(%rax,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    12f0 <sd_exec+0x190>
test   %r8,%r8
je     138c <sd_exec+0x22c>
lea    (%rax,%rbp,8),%rdi
add    $0x10,%rdi
lea    (%rbx,%rbp,8),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rsi,1),%xmm0
movups 0x0(%rbp,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    1370 <sd_exec+0x210>
cmp    %rcx,%rdx
je     1276 <sd_exec+0x116>
jmp    1201 <sd_exec+0xa1>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [10 x i8] c"exec: %s\0A\00"
@errno = global i32 0
define i32 @sd_exec(i32 %0, i8** %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8**
%13 = alloca i32
store i32 %0, i32* %7
store i8** %1, i8*** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
%14 = load i32, i32* %7
%15 = icmp eq i32 %14, 0
br i1 %15, label %16, label %17
16: ; preds = %5
store i32 0, i32* %6
br label %77
17: ; preds = %5
%18 = load i32, i32* %9
%19 = icmp ne i32 %18, 0
br i1 %19, label %20, label %24
20: ; preds = %17
%21 = call i32 @close(i32 0)
%22 = load i32, i32* %9
%23 = call i32 @dup(i32 %22)
br label %24
24: ; preds = %20, %17
%25 = load i32, i32* %10
%26 = icmp ne i32 %25, 1
br i1 %26, label %27, label %31
27: ; preds = %24
%28 = call i32 @close(i32 1)
%29 = load i32, i32* %10
%30 = call i32 @dup(i32 %29)
br label %31
31: ; preds = %27, %24
%32 = load i32, i32* %11
%33 = icmp ne i32 %32, 2
br i1 %33, label %34, label %42
34: ; preds = %31
%35 = load i32, i32* %11
%36 = load i32, i32* %10
%37 = icmp ne i32 %35, %36
br i1 %37, label %38, label %42
38: ; preds = %34
%39 = call i32 @close(i32 2)
%40 = load i32, i32* %11
%41 = call i32 @dup(i32 %40)
br label %42
42: ; preds = %38, %34, %31
%43 = load i32, i32* %7
%44 = add nsw i32 %43, 1
%45 = call i8** @xcalloc(i32 %44, i32 8)
store i8** %45, i8*** %12
store i32 0, i32* %13
br label %46
46: ; preds = %60, %42
%47 = load i32, i32* %13
%48 = load i32, i32* %7
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %63
50: ; preds = %46
%51 = load i8**, i8*** %8
%52 = load i32, i32* %13
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8*, i8** %51, i64 %53
%55 = load i8*, i8** %54
%56 = load i8**, i8*** %12
%57 = load i32, i32* %13
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8*, i8** %56, i64 %58
store i8* %55, i8** %59
br label %60
60: ; preds = %50
%61 = load i32, i32* %13
%62 = add nsw i32 %61, 1
store i32 %62, i32* %13
br label %46
63: ; preds = %46
%64 = load i8**, i8*** %12
%65 = load i32, i32* %13
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8*, i8** %64, i64 %66
store i8* null, i8** %67
%68 = load i8**, i8*** %12
%69 = getelementptr inbounds i8*, i8** %68, i64 0
%70 = load i8*, i8** %69
%71 = load i8**, i8*** %12
%72 = call i32 @execvp(i8* %70, i8** %71)
%73 = load i32, i32* @stderr
%74 = load i32, i32* @errno
%75 = call i8* @strerror(i32 %74)
%76 = call i32 @fprintf(i32 %73, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* %75)
store i32 1, i32* %6
br label %77
77: ; preds = %63, %16
%78 = load i32, i32* %6
ret i32 %78
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [10 x i8] c"exec: %s\0A\00"
@errno = global i32 0
define i32 @sd_exec(i32 %0, i8** nocapture %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp eq i32 %0, 0
br i1 %6, label %164, label %7
7: ; preds = %5
%8 = icmp eq i32 %2, 0
br i1 %8, label %12, label %9
9: ; preds = %7
%10 = tail call i32 @close(i32 0)
%11 = tail call i32 @dup(i32 %2)
br label %12
12: ; preds = %9, %7
%13 = icmp eq i32 %3, 1
br i1 %13, label %17, label %14
14: ; preds = %12
%15 = tail call i32 @close(i32 1)
%16 = tail call i32 @dup(i32 %3)
br label %17
17: ; preds = %14, %12
%18 = icmp eq i32 %4, 2
%19 = icmp eq i32 %4, %3
%20 = or i1 %18, %19
br i1 %20, label %24, label %21
21: ; preds = %17
%22 = tail call i32 @close(i32 2)
%23 = tail call i32 @dup(i32 %4)
br label %24
24: ; preds = %21, %17
%25 = add nsw i32 %0, 1
%26 = tail call i8** @xcalloc(i32 %25, i32 8)
%27 = icmp sgt i32 %0, 0
br i1 %27, label %28, label %155
28: ; preds = %24
%29 = zext i32 %0 to i64
%30 = icmp ult i32 %0, 4
br i1 %30, label %116, label %31
31: ; preds = %28
%32 = getelementptr i8*, i8** %26, i64 %29
%33 = getelementptr i8*, i8** %1, i64 %29
%34 = icmp ult i8** %26, %33
%35 = icmp ugt i8** %32, %1
%36 = and i1 %34, %35
br i1 %36, label %116, label %37
37: ; preds = %31
%38 = and i64 %29, 4294967292
%39 = add nsw i64 %38, -4
%40 = lshr exact i64 %39, 2
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 3
%43 = icmp ult i64 %39, 12
br i1 %43, label %95, label %44
44: ; preds = %37
%45 = and i64 %41, 9223372036854775804
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %92, %46 ]
%48 = phi i64 [ 0, %44 ], [ %93, %46 ]
%49 = getelementptr inbounds i8*, i8** %1, i64 %47
%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** %26, 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 %47, 4
%60 = getelementptr inbounds i8*, i8** %1, i64 %59
%61 = bitcast i8** %60 to <2 x i8*>*
%62 = load <2 x i8*>, <2 x i8*>* %61
%63 = getelementptr inbounds i8*, i8** %60, i64 2
%64 = bitcast i8** %63 to <2 x i8*>*
%65 = load <2 x i8*>, <2 x i8*>* %64
%66 = getelementptr inbounds i8*, i8** %26, i64 %59
%67 = bitcast i8** %66 to <2 x i8*>*
store <2 x i8*> %62, <2 x i8*>* %67
%68 = getelementptr inbounds i8*, i8** %66, i64 2
%69 = bitcast i8** %68 to <2 x i8*>*
store <2 x i8*> %65, <2 x i8*>* %69
%70 = or i64 %47, 8
%71 = getelementptr inbounds i8*, i8** %1, i64 %70
%72 = bitcast i8** %71 to <2 x i8*>*
%73 = load <2 x i8*>, <2 x i8*>* %72
%74 = getelementptr inbounds i8*, i8** %71, i64 2
%75 = bitcast i8** %74 to <2 x i8*>*
%76 = load <2 x i8*>, <2 x i8*>* %75
%77 = getelementptr inbounds i8*, i8** %26, i64 %70
%78 = bitcast i8** %77 to <2 x i8*>*
store <2 x i8*> %73, <2 x i8*>* %78
%79 = getelementptr inbounds i8*, i8** %77, i64 2
%80 = bitcast i8** %79 to <2 x i8*>*
store <2 x i8*> %76, <2 x i8*>* %80
%81 = or i64 %47, 12
%82 = getelementptr inbounds i8*, i8** %1, i64 %81
%83 = bitcast i8** %82 to <2 x i8*>*
%84 = load <2 x i8*>, <2 x i8*>* %83
%85 = getelementptr inbounds i8*, i8** %82, i64 2
%86 = bitcast i8** %85 to <2 x i8*>*
%87 = load <2 x i8*>, <2 x i8*>* %86
%88 = getelementptr inbounds i8*, i8** %26, i64 %81
%89 = bitcast i8** %88 to <2 x i8*>*
store <2 x i8*> %84, <2 x i8*>* %89
%90 = getelementptr inbounds i8*, i8** %88, i64 2
%91 = bitcast i8** %90 to <2 x i8*>*
store <2 x i8*> %87, <2 x i8*>* %91
%92 = add nuw i64 %47, 16
%93 = add nuw i64 %48, 4
%94 = icmp eq i64 %93, %45
br i1 %94, label %95, label %46
95: ; preds = %46, %37
%96 = phi i64 [ 0, %37 ], [ %92, %46 ]
%97 = icmp eq i64 %42, 0
br i1 %97, label %114, label %98
98: ; preds = %95, %98
%99 = phi i64 [ %111, %98 ], [ %96, %95 ]
%100 = phi i64 [ %112, %98 ], [ 0, %95 ]
%101 = getelementptr inbounds i8*, i8** %1, i64 %99
%102 = bitcast i8** %101 to <2 x i8*>*
%103 = load <2 x i8*>, <2 x i8*>* %102
%104 = getelementptr inbounds i8*, i8** %101, i64 2
%105 = bitcast i8** %104 to <2 x i8*>*
%106 = load <2 x i8*>, <2 x i8*>* %105
%107 = getelementptr inbounds i8*, i8** %26, i64 %99
%108 = bitcast i8** %107 to <2 x i8*>*
store <2 x i8*> %103, <2 x i8*>* %108
%109 = getelementptr inbounds i8*, i8** %107, i64 2
%110 = bitcast i8** %109 to <2 x i8*>*
store <2 x i8*> %106, <2 x i8*>* %110
%111 = add nuw i64 %99, 4
%112 = add i64 %100, 1
%113 = icmp eq i64 %112, %42
br i1 %113, label %114, label %98
114: ; preds = %98, %95
%115 = icmp eq i64 %38, %29
br i1 %115, label %153, label %116
116: ; preds = %31, %28, %114
%117 = phi i64 [ 0, %31 ], [ 0, %28 ], [ %38, %114 ]
%118 = xor i64 %117, -1
%119 = add nsw i64 %118, %29
%120 = and i64 %29, 3
%121 = icmp eq i64 %120, 0
br i1 %121, label %131, label %122
122: ; preds = %116, %122
%123 = phi i64 [ %128, %122 ], [ %117, %116 ]
%124 = phi i64 [ %129, %122 ], [ 0, %116 ]
%125 = getelementptr inbounds i8*, i8** %1, i64 %123
%126 = load i8*, i8** %125
%127 = getelementptr inbounds i8*, i8** %26, i64 %123
store i8* %126, i8** %127
%128 = add nuw nsw i64 %123, 1
%129 = add i64 %124, 1
%130 = icmp eq i64 %129, %120
br i1 %130, label %131, label %122
131: ; preds = %122, %116
%132 = phi i64 [ %117, %116 ], [ %128, %122 ]
%133 = icmp ult i64 %119, 3
br i1 %133, label %153, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %151, %134 ], [ %132, %131 ]
%136 = getelementptr inbounds i8*, i8** %1, i64 %135
%137 = load i8*, i8** %136
%138 = getelementptr inbounds i8*, i8** %26, i64 %135
store i8* %137, i8** %138
%139 = add nuw nsw i64 %135, 1
%140 = getelementptr inbounds i8*, i8** %1, i64 %139
%141 = load i8*, i8** %140
%142 = getelementptr inbounds i8*, i8** %26, i64 %139
store i8* %141, i8** %142
%143 = add nuw nsw i64 %135, 2
%144 = getelementptr inbounds i8*, i8** %1, i64 %143
%145 = load i8*, i8** %144
%146 = getelementptr inbounds i8*, i8** %26, i64 %143
store i8* %145, i8** %146
%147 = add nuw nsw i64 %135, 3
%148 = getelementptr inbounds i8*, i8** %1, i64 %147
%149 = load i8*, i8** %148
%150 = getelementptr inbounds i8*, i8** %26, i64 %147
store i8* %149, i8** %150
%151 = add nuw nsw i64 %135, 4
%152 = icmp eq i64 %151, %29
br i1 %152, label %153, label %134
153: ; preds = %131, %134, %114
%154 = zext i32 %0 to i64
br label %155
155: ; preds = %24, %153
%156 = phi i64 [ %154, %153 ], [ 0, %24 ]
%157 = getelementptr inbounds i8*, i8** %26, i64 %156
store i8* null, i8** %157
%158 = load i8*, i8** %26
%159 = tail call i32 @execvp(i8* %158, i8** %26)
%160 = load i32, i32* @stderr
%161 = load i32, i32* @errno
%162 = tail call i8* @strerror(i32 %161)
%163 = tail call i32 @fprintf(i32 %160, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* %162)
br label %164
164: ; preds = %5, %155
%165 = phi i32 [ 1, %155 ], [ 0, %5 ]
ret i32 %165
}