#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 */
typedef struct TYPE_4__ TYPE_2__;
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
struct TYPE_4__ {
  scalar_t__ tv_usec;
  scalar_t__ tv_sec;
};
struct TYPE_3__ {
  scalar_t__ tv_usec;
  scalar_t__ tv_sec;
};
struct rusage {
  int /*<<< orphan*/ ru_maxrss;
  TYPE_2__ ru_stime;
  TYPE_1__ ru_utime;
};
struct rlimit {
  int rlim_cur;
  int rlim_max;
};
typedef int /*<<< orphan*/ pid_t;

/* Variables and functions */
int /*<<< orphan*/ RLIMIT_AS;
int /*<<< orphan*/ RLIMIT_CPU;
int /*<<< orphan*/ RLIMIT_NPROC;
int /*<<< orphan*/ RLIMIT_STACK;
int /*<<< orphan*/ RUSAGE_CHILDREN;
int atoll(char *);
int /*<<< orphan*/ execv(char *, char **);
int /*<<< orphan*/ fork();
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int, scalar_t__,
                           int /*<<< orphan*/);
int /*<<< orphan*/ freopen(char *, char *, int /*<<< orphan*/);
int /*<<< orphan*/ getrusage(int /*<<< orphan*/, struct rusage *);
scalar_t__ malloc(int);
int /*<<< orphan*/ setrlimit(int /*<<< orphan*/, struct rlimit *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdin;
int /*<<< orphan*/ wait(int *);
int main(int argc, char *argv[]) {
  int tl = atoll(argv[1]);
  int ml = atoll(argv[2]);
  pid_t pid = fork();
  if (!pid) {
    struct rlimit *tmp1 = (struct rlimit *)malloc(sizeof(struct rlimit));
    tmp1->rlim_cur = tmp1->rlim_max = tl;
    setrlimit(RLIMIT_CPU, tmp1);
    struct rlimit *tmp2 = (struct rlimit *)malloc(sizeof(struct rlimit));
    tmp2->rlim_cur = tmp2->rlim_max = ml;
    setrlimit(RLIMIT_AS, tmp2);
    setrlimit(RLIMIT_STACK, tmp2);
    struct rlimit *tmp3 = (struct rlimit *)malloc(sizeof(struct rlimit));
    tmp3->rlim_cur = tmp3->rlim_max = 1;
    setrlimit(RLIMIT_NPROC, tmp3);
    freopen(argv[4], "r", stdin);
    freopen("/dev/null", "w", stderr);
    char *agv[] = {argv[3], NULL};
    execv(argv[3], agv);
  } else {
    int status;
    wait(&status);
    struct rusage *info = (struct rusage *)malloc(sizeof(struct rusage));
    getrusage(RUSAGE_CHILDREN, info);
    int stat;
    if (status == 0)
      stat = 0;
    else if (status == 9 || status == 32512)
      stat = 1;
    else
      stat = 2;
    fprintf(stderr, "%d %lld %ld\n", stat,
            ((unsigned long long int)(info->ru_utime.tv_sec +
                                      info->ru_stime.tv_sec)) *
                    1000000 +
                info->ru_utime.tv_usec + info->ru_stime.tv_usec,
            info->ru_maxrss);
    return 0;
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1040 <atoll@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1040 <atoll@plt>
mov    %eax,-0x18(%rbp)
mov    $0x0,%al
call   10b0 <fork@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    12e4 <main+0x154>
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    0x2da9(%rip),%rax
mov    (%rax),%edi
mov    -0x28(%rbp),%rsi
call   1070 <setrlimit@plt>
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    0x2d89(%rip),%rax
mov    (%rax),%edi
mov    -0x30(%rbp),%rsi
call   1070 <setrlimit@plt>
mov    0x2d7f(%rip),%rax
mov    (%rax),%edi
mov    -0x30(%rbp),%rsi
call   1070 <setrlimit@plt>
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movl   $0x1,0x4(%rax)
mov    -0x38(%rbp),%rax
movl   $0x1,(%rax)
mov    0x2d6a(%rip),%rax
mov    (%rax),%edi
mov    -0x38(%rbp),%rsi
call   1070 <setrlimit@plt>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rdi
mov    0x2d58(%rip),%rax
mov    (%rax),%edx
lea    0xd67(%rip),%rsi
call   1030 <freopen@plt>
mov    0x2d2b(%rip),%rax
mov    (%rax),%edx
lea    0xd54(%rip),%rdi
lea    0xd57(%rip),%rsi
call   1030 <freopen@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
lea    -0x50(%rbp),%rsi
call   10a0 <execv@plt>
jmp    139f <main+0x20f>
lea    -0x54(%rbp),%rdi
call   1090 <wait@plt>
mov    $0x28,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    0x2cc6(%rip),%rax
mov    (%rax),%edi
mov    -0x60(%rbp),%rsi
call   1080 <getrusage@plt>
cmpl   $0x0,-0x54(%rbp)
jne    1323 <main+0x193>
movl   $0x0,-0x64(%rbp)
jmp    1352 <main+0x1c2>
cmpl   $0x9,-0x54(%rbp)
je     133a <main+0x1aa>
cmpl   $0x7f00,-0x54(%rbp)
jne    1346 <main+0x1b6>
movl   $0x1,-0x64(%rbp)
jmp    134d <main+0x1bd>
movl   $0x2,-0x64(%rbp)
jmp    1352 <main+0x1c2>
mov    0x2c77(%rip),%rax
mov    (%rax),%edi
mov    -0x64(%rbp),%edx
mov    -0x60(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x60(%rbp),%rcx
add    0x10(%rcx),%rax
imul   $0xf4240,%rax,%rcx
mov    -0x60(%rbp),%rax
add    0x18(%rax),%rcx
mov    -0x60(%rbp),%rax
add    0x8(%rax),%rcx
mov    -0x60(%rbp),%rax
mov    (%rax),%r8d
lea    0xc7b(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
call   1040 <atoll@plt>
mov    %eax,%ebp
mov    0x10(%rbx),%rdi
call   1040 <atoll@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   10b0 <fork@plt>
test   %eax,%eax
je     1209 <main+0x79>
mov    %rsp,%rdi
call   1090 <wait@plt>
mov    $0x28,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    0x2def(%rip),%rax
mov    (%rax),%edi
mov    %rbx,%rsi
call   1080 <getrusage@plt>
mov    (%rsp),%edx
test   %edx,%edx
je     12dc <main+0x14c>
cmp    $0x9,%edx
je     11ff <main+0x6f>
cmp    $0x7f00,%edx
jne    12d7 <main+0x147>
mov    $0x1,%edx
jmp    12dc <main+0x14c>
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %ebp,0x4(%rax)
mov    %ebp,(%rax)
mov    0x2d89(%rip),%rcx
mov    (%rcx),%edi
mov    %rax,%rsi
call   1070 <setrlimit@plt>
mov    $0x8,%edi
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    %r14d,0x4(%rax)
mov    %r14d,(%rax)
mov    0x2d74(%rip),%rax
mov    (%rax),%edi
mov    %rbp,%rsi
call   1070 <setrlimit@plt>
mov    0x2d6b(%rip),%rax
mov    (%rax),%edi
mov    %rbp,%rsi
call   1070 <setrlimit@plt>
mov    $0x8,%edi
call   1060 <malloc@plt>
movabs $0x100000001,%rcx
mov    %rcx,(%rax)
mov    0x2d63(%rip),%rcx
mov    (%rcx),%edi
mov    %rax,%rsi
call   1070 <setrlimit@plt>
mov    0x20(%rbx),%rdi
mov    0x2d56(%rip),%rax
mov    (%rax),%edx
lea    0xd65(%rip),%rsi
call   1030 <freopen@plt>
mov    0x2d29(%rip),%rax
mov    (%rax),%edx
lea    0xd52(%rip),%rdi
lea    0xd55(%rip),%rsi
call   1030 <freopen@plt>
mov    0x18(%rbx),%rdi
mov    %rdi,(%rsp)
movq   $0x0,0x8(%rsp)
mov    %rsp,%rsi
call   10a0 <execv@plt>
jmp    130b <main+0x17b>
mov    $0x2,%edx
mov    0x10(%rbx),%rax
add    0x20(%rbx),%rax
mov    0x2ce5(%rip),%rsi
imul   $0xf4240,%rax,%rcx
add    0x18(%rbx),%rcx
mov    (%rsi),%edi
add    0x8(%rbx),%rcx
mov    (%rbx),%r8d
lea    0xd08(%rip),%rsi
call   1050 <fprintf@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
%struct.rlimit = type { i32, i32 }
%struct.rusage = type { i32, %struct.TYPE_4__, %struct.TYPE_3__ }
%struct.TYPE_4__ = type { i64, i64 }
%struct.TYPE_3__ = type { i64, i64 }
@RLIMIT_CPU = global i32 0
@RLIMIT_AS = global i32 0
@RLIMIT_STACK = global i32 0
@RLIMIT_NPROC = global i32 0
@.str = [2 x i8] c"r\00"
@stdin = global i32 0
@.str.1 = [10 x i8] c"/dev/null\00"
@.str.2 = [2 x i8] c"w\00"
@stderr = global i32 0
@RUSAGE_CHILDREN = global i32 0
@.str.3 = [13 x i8] c"%d %lld %ld\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca %struct.rlimit*
%10 = alloca %struct.rlimit*
%11 = alloca %struct.rlimit*
%12 = alloca [2 x i8*]
%13 = alloca i32
%14 = alloca %struct.rusage*
%15 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%16 = load i8**, i8*** %5
%17 = getelementptr inbounds i8*, i8** %16, i64 1
%18 = load i8*, i8** %17
%19 = call i32 @atoll(i8* %18)
store i32 %19, i32* %6
%20 = load i8**, i8*** %5
%21 = getelementptr inbounds i8*, i8** %20, i64 2
%22 = load i8*, i8** %21
%23 = call i32 @atoll(i8* %22)
store i32 %23, i32* %7
%24 = call i32 (...) @fork()
store i32 %24, i32* %8
%25 = load i32, i32* %8
%26 = icmp ne i32 %25, 0
br i1 %26, label %77, label %27
27: ; preds = %2
%28 = call i64 @malloc(i32 8)
%29 = inttoptr i64 %28 to %struct.rlimit*
store %struct.rlimit* %29, %struct.rlimit** %9
%30 = load i32, i32* %6
%31 = load %struct.rlimit*, %struct.rlimit** %9
%32 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %31, i32 0, i32 1
store i32 %30, i32* %32
%33 = load %struct.rlimit*, %struct.rlimit** %9
%34 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %33, i32 0, i32 0
store i32 %30, i32* %34
%35 = load i32, i32* @RLIMIT_CPU
%36 = load %struct.rlimit*, %struct.rlimit** %9
%37 = call i32 @setrlimit(i32 %35, %struct.rlimit* %36)
%38 = call i64 @malloc(i32 8)
%39 = inttoptr i64 %38 to %struct.rlimit*
store %struct.rlimit* %39, %struct.rlimit** %10
%40 = load i32, i32* %7
%41 = load %struct.rlimit*, %struct.rlimit** %10
%42 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %41, i32 0, i32 1
store i32 %40, i32* %42
%43 = load %struct.rlimit*, %struct.rlimit** %10
%44 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %43, i32 0, i32 0
store i32 %40, i32* %44
%45 = load i32, i32* @RLIMIT_AS
%46 = load %struct.rlimit*, %struct.rlimit** %10
%47 = call i32 @setrlimit(i32 %45, %struct.rlimit* %46)
%48 = load i32, i32* @RLIMIT_STACK
%49 = load %struct.rlimit*, %struct.rlimit** %10
%50 = call i32 @setrlimit(i32 %48, %struct.rlimit* %49)
%51 = call i64 @malloc(i32 8)
%52 = inttoptr i64 %51 to %struct.rlimit*
store %struct.rlimit* %52, %struct.rlimit** %11
%53 = load %struct.rlimit*, %struct.rlimit** %11
%54 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %53, i32 0, i32 1
store i32 1, i32* %54
%55 = load %struct.rlimit*, %struct.rlimit** %11
%56 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %55, i32 0, i32 0
store i32 1, i32* %56
%57 = load i32, i32* @RLIMIT_NPROC
%58 = load %struct.rlimit*, %struct.rlimit** %11
%59 = call i32 @setrlimit(i32 %57, %struct.rlimit* %58)
%60 = load i8**, i8*** %5
%61 = getelementptr inbounds i8*, i8** %60, i64 4
%62 = load i8*, i8** %61
%63 = load i32, i32* @stdin
%64 = call i32 @freopen(i8* %62, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 %63)
%65 = load i32, i32* @stderr
%66 = call i32 @freopen(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 %65)
%67 = getelementptr inbounds [2 x i8*], [2 x i8*]* %12, i64 0, i64 0
%68 = load i8**, i8*** %5
%69 = getelementptr inbounds i8*, i8** %68, i64 3
%70 = load i8*, i8** %69
store i8* %70, i8** %67
%71 = getelementptr inbounds i8*, i8** %67, i64 1
store i8* null, i8** %71
%72 = load i8**, i8*** %5
%73 = getelementptr inbounds i8*, i8** %72, i64 3
%74 = load i8*, i8** %73
%75 = getelementptr inbounds [2 x i8*], [2 x i8*]* %12, i64 0, i64 0
%76 = call i32 @execv(i8* %74, i8** %75)
br label %123
77: ; preds = %2
%78 = call i32 @wait(i32* %13)
%79 = call i64 @malloc(i32 40)
%80 = inttoptr i64 %79 to %struct.rusage*
store %struct.rusage* %80, %struct.rusage** %14
%81 = load i32, i32* @RUSAGE_CHILDREN
%82 = load %struct.rusage*, %struct.rusage** %14
%83 = call i32 @getrusage(i32 %81, %struct.rusage* %82)
%84 = load i32, i32* %13
%85 = icmp eq i32 %84, 0
br i1 %85, label %86, label %87
86: ; preds = %77
store i32 0, i32* %15
br label %96
87: ; preds = %77
%88 = load i32, i32* %13
%89 = icmp eq i32 %88, 9
br i1 %89, label %93, label %90
90: ; preds = %87
%91 = load i32, i32* %13
%92 = icmp eq i32 %91, 32512
br i1 %92, label %93, label %94
93: ; preds = %90, %87
store i32 1, i32* %15
br label %95
94: ; preds = %90
store i32 2, i32* %15
br label %95
95: ; preds = %94, %93
br label %96
96: ; preds = %95, %86
%97 = load i32, i32* @stderr
%98 = load i32, i32* %15
%99 = load %struct.rusage*, %struct.rusage** %14
%100 = getelementptr inbounds %struct.rusage, %struct.rusage* %99, i32 0, i32 2
%101 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %100, i32 0, i32 1
%102 = load i64, i64* %101
%103 = load %struct.rusage*, %struct.rusage** %14
%104 = getelementptr inbounds %struct.rusage, %struct.rusage* %103, i32 0, i32 1
%105 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %104, i32 0, i32 1
%106 = load i64, i64* %105
%107 = add nsw i64 %102, %106
%108 = mul i64 %107, 1000000
%109 = load %struct.rusage*, %struct.rusage** %14
%110 = getelementptr inbounds %struct.rusage, %struct.rusage* %109, i32 0, i32 2
%111 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %110, i32 0, i32 0
%112 = load i64, i64* %111
%113 = add i64 %108, %112
%114 = load %struct.rusage*, %struct.rusage** %14
%115 = getelementptr inbounds %struct.rusage, %struct.rusage* %114, i32 0, i32 1
%116 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %115, i32 0, i32 0
%117 = load i64, i64* %116
%118 = add i64 %113, %117
%119 = load %struct.rusage*, %struct.rusage** %14
%120 = getelementptr inbounds %struct.rusage, %struct.rusage* %119, i32 0, i32 0
%121 = load i32, i32* %120
%122 = call i32 @fprintf(i32 %97, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0), i32 %98, i64 %118, i32 %121)
store i32 0, i32* %3
br label %123
123: ; preds = %96, %27
%124 = load i32, i32* %3
ret i32 %124
}

LLVM IR (-O2):
%struct.rlimit = type { i32, i32 }
%struct.rusage = type { i32, %struct.TYPE_4__, %struct.TYPE_3__ }
%struct.TYPE_4__ = type { i64, i64 }
%struct.TYPE_3__ = type { i64, i64 }
@RLIMIT_CPU = global i32 0
@RLIMIT_AS = global i32 0
@RLIMIT_STACK = global i32 0
@RLIMIT_NPROC = global i32 0
@.str = [2 x i8] c"r\00"
@stdin = global i32 0
@.str.1 = [10 x i8] c"/dev/null\00"
@.str.2 = [2 x i8] c"w\00"
@stderr = global i32 0
@RUSAGE_CHILDREN = global i32 0
@.str.3 = [13 x i8] c"%d %lld %ld\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [2 x i8*]
%4 = alloca i32
%5 = getelementptr inbounds i8*, i8** %1, i64 1
%6 = load i8*, i8** %5
%7 = tail call i32 @atoll(i8* %6)
%8 = getelementptr inbounds i8*, i8** %1, i64 2
%9 = load i8*, i8** %8
%10 = tail call i32 @atoll(i8* %9)
%11 = tail call i32 (...) @fork()
%12 = icmp eq i32 %11, 0
br i1 %12, label %13, label %46
13: ; preds = %2
%14 = tail call i64 @malloc(i32 8)
%15 = inttoptr i64 %14 to %struct.rlimit*
%16 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %15, i64 0, i32 1
store i32 %7, i32* %16
%17 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %15, i64 0, i32 0
store i32 %7, i32* %17
%18 = load i32, i32* @RLIMIT_CPU
%19 = tail call i32 @setrlimit(i32 %18, %struct.rlimit* %15)
%20 = tail call i64 @malloc(i32 8)
%21 = inttoptr i64 %20 to %struct.rlimit*
%22 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %21, i64 0, i32 1
store i32 %10, i32* %22
%23 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %21, i64 0, i32 0
store i32 %10, i32* %23
%24 = load i32, i32* @RLIMIT_AS
%25 = tail call i32 @setrlimit(i32 %24, %struct.rlimit* %21)
%26 = load i32, i32* @RLIMIT_STACK
%27 = tail call i32 @setrlimit(i32 %26, %struct.rlimit* %21)
%28 = tail call i64 @malloc(i32 8)
%29 = inttoptr i64 %28 to %struct.rlimit*
%30 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %29, i64 0, i32 1
store i32 1, i32* %30
%31 = getelementptr inbounds %struct.rlimit, %struct.rlimit* %29, i64 0, i32 0
store i32 1, i32* %31
%32 = load i32, i32* @RLIMIT_NPROC
%33 = tail call i32 @setrlimit(i32 %32, %struct.rlimit* %29)
%34 = getelementptr inbounds i8*, i8** %1, i64 4
%35 = load i8*, i8** %34
%36 = load i32, i32* @stdin
%37 = tail call i32 @freopen(i8* %35, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 %36)
%38 = load i32, i32* @stderr
%39 = tail call i32 @freopen(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 %38)
%40 = bitcast [2 x i8*]* %3 to i8*
%41 = getelementptr inbounds [2 x i8*], [2 x i8*]* %3, i64 0, i64 0
%42 = getelementptr inbounds i8*, i8** %1, i64 3
%43 = load i8*, i8** %42
store i8* %43, i8** %41
%44 = getelementptr inbounds [2 x i8*], [2 x i8*]* %3, i64 0, i64 1
store i8* null, i8** %44
%45 = call i32 @execv(i8* %43, i8** %41)
br label %74
46: ; preds = %2
%47 = bitcast i32* %4 to i8*
%48 = call i32 @wait(i32* %4)
%49 = call i64 @malloc(i32 40)
%50 = inttoptr i64 %49 to %struct.rusage*
%51 = load i32, i32* @RUSAGE_CHILDREN
%52 = call i32 @getrusage(i32 %51, %struct.rusage* %50)
%53 = load i32, i32* %4
switch i32 %53, label %54 [
i32 0, label %56
i32 32512, label %55
i32 9, label %55
]
54: ; preds = %46
br label %56
55: ; preds = %46, %46
br label %56
56: ; preds = %46, %55, %54
%57 = phi i32 [ 2, %54 ], [ %53, %46 ], [ 1, %55 ]
%58 = load i32, i32* @stderr
%59 = getelementptr inbounds %struct.rusage, %struct.rusage* %50, i64 0, i32 2, i32 1
%60 = load i64, i64* %59
%61 = getelementptr inbounds %struct.rusage, %struct.rusage* %50, i64 0, i32 1, i32 1
%62 = load i64, i64* %61
%63 = add nsw i64 %62, %60
%64 = mul i64 %63, 1000000
%65 = getelementptr inbounds %struct.rusage, %struct.rusage* %50, i64 0, i32 2, i32 0
%66 = load i64, i64* %65
%67 = add i64 %64, %66
%68 = getelementptr inbounds %struct.rusage, %struct.rusage* %50, i64 0, i32 1, i32 0
%69 = load i64, i64* %68
%70 = add i64 %67, %69
%71 = getelementptr inbounds %struct.rusage, %struct.rusage* %50, i64 0, i32 0
%72 = load i32, i32* %71
%73 = call i32 @fprintf(i32 %58, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0), i32 %57, i64 %70, i32 %72)
br label %74
74: ; preds = %13, %56
ret i32 0
}