#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_2__ TYPE_1__;

/* Type definitions */
struct TYPE_2__ {
  int /*<<< orphan*/ tv_sec;
};
struct utmpx {
  int ut_type;
  char *ut_host;
  char *ut_line;
  char *ut_id;
  char *ut_user;
  scalar_t__ ut_pid;
  TYPE_1__ ut_tv;
};
struct utmp {
  char *ut_line;
  char *ut_name;
  char *ut_host;
  int /*<<< orphan*/ ut_time;
};

/* Variables and functions */
#define ACCOUNTING 137
#define BOOT_TIME 136
#define DEAD_PROCESS 135
#define EMPTY 134
#define INIT_PROCESS 133
#define LOGIN_PROCESS 132
#define NEW_TIME 131
#define OLD_TIME 130
#define RUN_LVL 129
#define USER_PROCESS 128
int UT_HOSTSIZE;
size_t UT_LINESIZE;
size_t UT_NAMESIZE;
int /*<<< orphan*/ sprintf(char *, char *, unsigned long);
size_t strlen(char *);
int /*<<< orphan*/ strncpy(char *, char *, size_t);
int __utmpx_to_utmp(const struct utmpx *ux, struct utmp *u) {
  char buf[10 + 1];
  switch (ux->ut_type) {
  case EMPTY:
    strncpy(u->ut_line, "", UT_LINESIZE);
    strncpy(u->ut_name, "", UT_NAMESIZE);
    strncpy(u->ut_host, "", UT_HOSTSIZE);
    break;
  case RUN_LVL:
    strncpy(u->ut_line, "~", UT_LINESIZE);
    strncpy(u->ut_name, "runlevel", UT_NAMESIZE);
    strncpy(u->ut_host, ux->ut_host, UT_HOSTSIZE);
    break;
  case BOOT_TIME:
    strncpy(u->ut_line, "~", UT_LINESIZE);
    strncpy(u->ut_name, "reboot", UT_NAMESIZE);
    strncpy(u->ut_host, ux->ut_host, UT_HOSTSIZE);
    break;
  case NEW_TIME:
    strncpy(u->ut_line, "{", UT_LINESIZE);
    strncpy(u->ut_name, "date", UT_NAMESIZE);
    strncpy(u->ut_host, ux->ut_host, UT_HOSTSIZE);
    break;
  case OLD_TIME:
    strncpy(u->ut_line, "|", UT_LINESIZE);
    strncpy(u->ut_name, "date", UT_NAMESIZE);
    strncpy(u->ut_host, ux->ut_host, UT_HOSTSIZE);
    break;
  case INIT_PROCESS:
  case LOGIN_PROCESS:
  case USER_PROCESS:
  case DEAD_PROCESS:
    if (ux->ut_line[0] != '\0')
      strncpy(u->ut_line, ux->ut_line, UT_LINESIZE);
    else
      strncpy(u->ut_line, ux->ut_id, sizeof(ux->ut_id));
    switch (ux->ut_type) {
    case INIT_PROCESS:
      strncpy(u->ut_name, "INIT", UT_NAMESIZE);
      break;
    case LOGIN_PROCESS:
      strncpy(u->ut_name, "LOGIN", UT_NAMESIZE);
      break;
    case USER_PROCESS:
      strncpy(u->ut_name, ux->ut_user, UT_NAMESIZE);
      break;
    case DEAD_PROCESS:
      strncpy(u->ut_name, "", UT_NAMESIZE);
      break;
    }
    strncpy(u->ut_host, ux->ut_host, UT_HOSTSIZE);
    break;
  case ACCOUNTING:
    strncpy(u->ut_line, "~", UT_LINESIZE);
    strncpy(u->ut_name, "acct", UT_NAMESIZE);
    strncpy(u->ut_host, ux->ut_host, UT_HOSTSIZE);
    break;
  default:
    return -1;
  }
  u->ut_time = ux->ut_tv.tv_sec;
  if (ux->ut_pid != 0) {
    size_t room = UT_HOSTSIZE - strlen(u->ut_host) - 1;
    sprintf(buf, "%lu", (unsigned long)ux->ut_pid);
    if (strlen(buf) <= room)
      strncpy(u->ut_host + strlen(u->ut_host) + 1, buf, room);
  }
  return 0;
}


x86 assembly (clang, -O0):
<__utmpx_to_utmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    $0xffffff80,%eax
mov    %eax,%ecx
mov    %rcx,-0x38(%rbp)
sub    $0x9,%eax
ja     14cd <__utmpx_to_utmp+0x39d>
mov    -0x38(%rbp),%rax
lea    0xe9d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    0x2e66(%rip),%rax
mov    (%rax),%rdx
lea    0xee9(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2e60(%rip),%rax
mov    (%rax),%rdx
lea    0xecb(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
mov    0x2e1a(%rip),%rax
movslq (%rax),%rdx
lea    0xead(%rip),%rsi
call   1030 <strncpy@plt>
jmp    14d9 <__utmpx_to_utmp+0x3a9>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    0x2e08(%rip),%rax
mov    (%rax),%rdx
lea    0xe66(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2e02(%rip),%rax
mov    (%rax),%rdx
lea    0xe4a(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    0x2db4(%rip),%rax
movslq (%rax),%rdx
call   1030 <strncpy@plt>
jmp    14d9 <__utmpx_to_utmp+0x3a9>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    0x2da9(%rip),%rax
mov    (%rax),%rdx
lea    0xe07(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2da3(%rip),%rax
mov    (%rax),%rdx
lea    0xdf4(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    0x2d55(%rip),%rax
movslq (%rax),%rdx
call   1030 <strncpy@plt>
jmp    14d9 <__utmpx_to_utmp+0x3a9>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    0x2d4a(%rip),%rax
mov    (%rax),%rdx
lea    0xdba(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2d44(%rip),%rax
mov    (%rax),%rdx
lea    0xd9e(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    0x2cf6(%rip),%rax
movslq (%rax),%rdx
call   1030 <strncpy@plt>
jmp    14d9 <__utmpx_to_utmp+0x3a9>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    0x2ceb(%rip),%rax
mov    (%rax),%rdx
lea    0xd62(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2ce5(%rip),%rax
mov    (%rax),%rdx
lea    0xd3f(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    0x2c97(%rip),%rax
movslq (%rax),%rdx
call   1030 <strncpy@plt>
jmp    14d9 <__utmpx_to_utmp+0x3a9>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     137d <__utmpx_to_utmp+0x24d>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rsi
mov    0x2c70(%rip),%rax
mov    (%rax),%rdx
call   1030 <strncpy@plt>
jmp    1396 <__utmpx_to_utmp+0x266>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rsi
mov    $0x8,%edx
call   1030 <strncpy@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    $0xffffff80,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x7,%eax
ja     144a <__utmpx_to_utmp+0x31a>
mov    -0x40(%rbp),%rax
lea    0xc6f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2c27(%rip),%rax
mov    (%rax),%rdx
lea    0xc88(%rip),%rsi
call   1030 <strncpy@plt>
jmp    144a <__utmpx_to_utmp+0x31a>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2c04(%rip),%rax
mov    (%rax),%rdx
lea    0xc6a(%rip),%rsi
call   1030 <strncpy@plt>
jmp    144a <__utmpx_to_utmp+0x31a>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rsi
mov    0x2bd9(%rip),%rax
mov    (%rax),%rdx
call   1030 <strncpy@plt>
jmp    144a <__utmpx_to_utmp+0x31a>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2bbd(%rip),%rax
mov    (%rax),%rdx
lea    0xc28(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    0x2b6f(%rip),%rax
movslq (%rax),%rdx
call   1030 <strncpy@plt>
jmp    14d9 <__utmpx_to_utmp+0x3a9>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    0x2b64(%rip),%rax
mov    (%rax),%rdx
lea    0xbc2(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2b5e(%rip),%rax
mov    (%rax),%rdx
lea    0xbca(%rip),%rsi
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    0x2b10(%rip),%rax
movslq (%rax),%rdx
call   1030 <strncpy@plt>
jmp    14d9 <__utmpx_to_utmp+0x3a9>
movl   $0xffffffff,-0x4(%rbp)
jmp    158b <__utmpx_to_utmp+0x45b>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x10(%rbp),%rax
cmpq   $0x0,0x28(%rax)
je     1584 <__utmpx_to_utmp+0x454>
mov    0x2ad3(%rip),%rax
movslq (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x48(%rbp),%rax
sub    %rcx,%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
lea    -0x23(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rdx
lea    0xb3d(%rip),%rsi
call   1050 <sprintf@plt>
lea    -0x23(%rbp),%rdi
call   1040 <strlen@plt>
cmp    -0x30(%rbp),%rax
ja     157f <__utmpx_to_utmp+0x44f>
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rdi
call   1040 <strlen@plt>
mov    -0x50(%rbp),%rdi
add    %rax,%rdi
add    $0x1,%rdi
lea    -0x23(%rbp),%rsi
mov    -0x30(%rbp),%rdx
call   1030 <strncpy@plt>
jmp    1584 <__utmpx_to_utmp+0x454>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<__utmpx_to_utmp>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    (%rdi),%eax
add    $0xffffff80,%eax
cmp    $0x9,%eax
ja     126b <__utmpx_to_utmp+0x13b>
mov    %rsi,%r14
mov    %rdi,%r15
lea    0xea9(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x10(%r15),%rsi
cmpb   $0x0,(%rsi)
mov    (%r14),%rdi
je     1178 <__utmpx_to_utmp+0x48>
mov    0x2e6d(%rip),%rax
mov    (%rax),%rdx
jmp    1181 <__utmpx_to_utmp+0x51>
mov    0x18(%r15),%rsi
mov    $0x8,%edx
call   1030 <strncpy@plt>
mov    (%r15),%eax
add    $0xffffff80,%eax
cmp    $0x7,%eax
ja     12f9 <__utmpx_to_utmp+0x1c9>
lea    0xec7(%rip),%rsi
lea    0xe85(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x20(%r15),%rsi
jmp    12e6 <__utmpx_to_utmp+0x1b6>
mov    (%r14),%rdi
mov    0x2e21(%rip),%rax
mov    (%rax),%rdx
lea    0xe7f(%rip),%rsi
call   1030 <strncpy@plt>
mov    0x8(%r14),%rdi
mov    0x2e1f(%rip),%rax
mov    (%rax),%rdx
lea    0xe67(%rip),%rsi
jmp    12f4 <__utmpx_to_utmp+0x1c4>
mov    (%r14),%rdi
mov    0x2dee(%rip),%rax
mov    (%rax),%rdx
lea    0xe65(%rip),%rsi
jmp    128a <__utmpx_to_utmp+0x15a>
mov    (%r14),%rdi
mov    0x2dd5(%rip),%rax
mov    (%rax),%rdx
lea    0xe58(%rip),%rbx
mov    %rbx,%rsi
call   1030 <strncpy@plt>
mov    0x8(%r14),%rdi
mov    0x2dd0(%rip),%rax
mov    (%rax),%rdx
mov    %rbx,%rsi
call   1030 <strncpy@plt>
jmp    12fd <__utmpx_to_utmp+0x1cd>
mov    (%r14),%rdi
mov    0x2d9e(%rip),%rax
mov    (%rax),%rdx
lea    0xdfc(%rip),%rsi
call   1030 <strncpy@plt>
mov    0x8(%r14),%rdi
mov    0x2d9c(%rip),%rax
mov    (%rax),%rdx
lea    0xe08(%rip),%rsi
jmp    12f4 <__utmpx_to_utmp+0x1c4>
mov    $0xffffffff,%r15d
jmp    1383 <__utmpx_to_utmp+0x253>
mov    (%r14),%rdi
mov    0x2d60(%rip),%rax
mov    (%rax),%rdx
lea    0xdd0(%rip),%rsi
call   1030 <strncpy@plt>
mov    0x8(%r14),%rdi
mov    0x2d5e(%rip),%rax
mov    (%rax),%rdx
lea    0xdb8(%rip),%rsi
jmp    12f4 <__utmpx_to_utmp+0x1c4>
mov    (%r14),%rdi
mov    0x2d30(%rip),%rax
mov    (%rax),%rdx
lea    0xd8e(%rip),%rsi
call   1030 <strncpy@plt>
mov    0x8(%r14),%rdi
mov    0x2d2e(%rip),%rax
mov    (%rax),%rdx
lea    0xd7f(%rip),%rsi
jmp    12f4 <__utmpx_to_utmp+0x1c4>
lea    0xd8b(%rip),%rsi
jmp    12e6 <__utmpx_to_utmp+0x1b6>
lea    0xd87(%rip),%rsi
mov    0x8(%r14),%rdi
mov    0x2d07(%rip),%rax
mov    (%rax),%rdx
call   1030 <strncpy@plt>
mov    0x8(%r15),%rbx
mov    0x10(%r14),%rdi
mov    0x2cc8(%rip),%r12
movslq (%r12),%rdx
mov    %rbx,%rsi
call   1030 <strncpy@plt>
mov    0x30(%r15),%eax
mov    %eax,0x18(%r14)
mov    0x28(%r15),%rbp
xor    %r15d,%r15d
test   %rbp,%rbp
je     1383 <__utmpx_to_utmp+0x253>
movslq (%r12),%r12
mov    0x10(%r14),%rdi
call   1040 <strlen@plt>
mov    %rax,%rbx
not    %rbx
add    %r12,%rbx
lea    0xd2e(%rip),%rsi
lea    0x5(%rsp),%r12
mov    %r12,%rdi
mov    %rbp,%rdx
call   1050 <sprintf@plt>
mov    %r12,%rdi
call   1040 <strlen@plt>
cmp    %rbx,%rax
ja     1383 <__utmpx_to_utmp+0x253>
mov    0x10(%r14),%rbp
mov    %rbp,%rdi
call   1040 <strlen@plt>
lea    (%rax,%rbp,1),%rdi
add    $0x1,%rdi
lea    0x5(%rsp),%rsi
mov    %rbx,%rdx
call   1030 <strncpy@plt>
mov    %r15d,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.utmpx = type { i32, i8*, i8*, i8*, i8*, i64, %struct.TYPE_2__ }
%struct.TYPE_2__ = type { i32 }
%struct.utmp = type { i8*, i8*, i8*, i32 }
@.str = [1 x i8] zeroinitializer
@UT_LINESIZE = global i64 0
@UT_NAMESIZE = global i64 0
@UT_HOSTSIZE = global i32 0
@.str.1 = [2 x i8] c"~\00"
@.str.2 = [9 x i8] c"runlevel\00"
@.str.3 = [7 x i8] c"reboot\00"
@.str.4 = [2 x i8] c"{\00"
@.str.5 = [5 x i8] c"date\00"
@.str.6 = [2 x i8] c"|\00"
@.str.7 = [5 x i8] c"INIT\00"
@.str.8 = [6 x i8] c"LOGIN\00"
@.str.9 = [5 x i8] c"acct\00"
@.str.10 = [4 x i8] c"%lu\00"
define i32 @__utmpx_to_utmp(%struct.utmpx* %0, %struct.utmp* %1) {
%3 = alloca i32
%4 = alloca %struct.utmpx*
%5 = alloca %struct.utmp*
%6 = alloca [11 x i8]
%7 = alloca i64
store %struct.utmpx* %0, %struct.utmpx** %4
store %struct.utmp* %1, %struct.utmp** %5
%8 = load %struct.utmpx*, %struct.utmpx** %4
%9 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %8, i32 0, i32 0
%10 = load i32, i32* %9
switch i32 %10, label %194 [
i32 134, label %11
i32 129, label %28
i32 136, label %48
i32 131, label %68
i32 130, label %88
i32 133, label %108
i32 132, label %108
i32 128, label %108
i32 135, label %108
i32 137, label %174
]
11: ; preds = %2
%12 = load %struct.utmp*, %struct.utmp** %5
%13 = getelementptr inbounds %struct.utmp, %struct.utmp* %12, i32 0, i32 0
%14 = load i8*, i8** %13
%15 = load i64, i64* @UT_LINESIZE
%16 = call i32 @strncpy(i8* %14, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 %15)
%17 = load %struct.utmp*, %struct.utmp** %5
%18 = getelementptr inbounds %struct.utmp, %struct.utmp* %17, i32 0, i32 1
%19 = load i8*, i8** %18
%20 = load i64, i64* @UT_NAMESIZE
%21 = call i32 @strncpy(i8* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 %20)
%22 = load %struct.utmp*, %struct.utmp** %5
%23 = getelementptr inbounds %struct.utmp, %struct.utmp* %22, i32 0, i32 2
%24 = load i8*, i8** %23
%25 = load i32, i32* @UT_HOSTSIZE
%26 = sext i32 %25 to i64
%27 = call i32 @strncpy(i8* %24, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 %26)
br label %195
28: ; preds = %2
%29 = load %struct.utmp*, %struct.utmp** %5
%30 = getelementptr inbounds %struct.utmp, %struct.utmp* %29, i32 0, i32 0
%31 = load i8*, i8** %30
%32 = load i64, i64* @UT_LINESIZE
%33 = call i32 @strncpy(i8* %31, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 %32)
%34 = load %struct.utmp*, %struct.utmp** %5
%35 = getelementptr inbounds %struct.utmp, %struct.utmp* %34, i32 0, i32 1
%36 = load i8*, i8** %35
%37 = load i64, i64* @UT_NAMESIZE
%38 = call i32 @strncpy(i8* %36, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i64 %37)
%39 = load %struct.utmp*, %struct.utmp** %5
%40 = getelementptr inbounds %struct.utmp, %struct.utmp* %39, i32 0, i32 2
%41 = load i8*, i8** %40
%42 = load %struct.utmpx*, %struct.utmpx** %4
%43 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %42, i32 0, i32 1
%44 = load i8*, i8** %43
%45 = load i32, i32* @UT_HOSTSIZE
%46 = sext i32 %45 to i64
%47 = call i32 @strncpy(i8* %41, i8* %44, i64 %46)
br label %195
48: ; preds = %2
%49 = load %struct.utmp*, %struct.utmp** %5
%50 = getelementptr inbounds %struct.utmp, %struct.utmp* %49, i32 0, i32 0
%51 = load i8*, i8** %50
%52 = load i64, i64* @UT_LINESIZE
%53 = call i32 @strncpy(i8* %51, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 %52)
%54 = load %struct.utmp*, %struct.utmp** %5
%55 = getelementptr inbounds %struct.utmp, %struct.utmp* %54, i32 0, i32 1
%56 = load i8*, i8** %55
%57 = load i64, i64* @UT_NAMESIZE
%58 = call i32 @strncpy(i8* %56, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i64 %57)
%59 = load %struct.utmp*, %struct.utmp** %5
%60 = getelementptr inbounds %struct.utmp, %struct.utmp* %59, i32 0, i32 2
%61 = load i8*, i8** %60
%62 = load %struct.utmpx*, %struct.utmpx** %4
%63 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %62, i32 0, i32 1
%64 = load i8*, i8** %63
%65 = load i32, i32* @UT_HOSTSIZE
%66 = sext i32 %65 to i64
%67 = call i32 @strncpy(i8* %61, i8* %64, i64 %66)
br label %195
68: ; preds = %2
%69 = load %struct.utmp*, %struct.utmp** %5
%70 = getelementptr inbounds %struct.utmp, %struct.utmp* %69, i32 0, i32 0
%71 = load i8*, i8** %70
%72 = load i64, i64* @UT_LINESIZE
%73 = call i32 @strncpy(i8* %71, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i64 %72)
%74 = load %struct.utmp*, %struct.utmp** %5
%75 = getelementptr inbounds %struct.utmp, %struct.utmp* %74, i32 0, i32 1
%76 = load i8*, i8** %75
%77 = load i64, i64* @UT_NAMESIZE
%78 = call i32 @strncpy(i8* %76, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i64 %77)
%79 = load %struct.utmp*, %struct.utmp** %5
%80 = getelementptr inbounds %struct.utmp, %struct.utmp* %79, i32 0, i32 2
%81 = load i8*, i8** %80
%82 = load %struct.utmpx*, %struct.utmpx** %4
%83 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %82, i32 0, i32 1
%84 = load i8*, i8** %83
%85 = load i32, i32* @UT_HOSTSIZE
%86 = sext i32 %85 to i64
%87 = call i32 @strncpy(i8* %81, i8* %84, i64 %86)
br label %195
88: ; preds = %2
%89 = load %struct.utmp*, %struct.utmp** %5
%90 = getelementptr inbounds %struct.utmp, %struct.utmp* %89, i32 0, i32 0
%91 = load i8*, i8** %90
%92 = load i64, i64* @UT_LINESIZE
%93 = call i32 @strncpy(i8* %91, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i64 %92)
%94 = load %struct.utmp*, %struct.utmp** %5
%95 = getelementptr inbounds %struct.utmp, %struct.utmp* %94, i32 0, i32 1
%96 = load i8*, i8** %95
%97 = load i64, i64* @UT_NAMESIZE
%98 = call i32 @strncpy(i8* %96, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i64 %97)
%99 = load %struct.utmp*, %struct.utmp** %5
%100 = getelementptr inbounds %struct.utmp, %struct.utmp* %99, i32 0, i32 2
%101 = load i8*, i8** %100
%102 = load %struct.utmpx*, %struct.utmpx** %4
%103 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %102, i32 0, i32 1
%104 = load i8*, i8** %103
%105 = load i32, i32* @UT_HOSTSIZE
%106 = sext i32 %105 to i64
%107 = call i32 @strncpy(i8* %101, i8* %104, i64 %106)
br label %195
108: ; preds = %2, %2, %2, %2
%109 = load %struct.utmpx*, %struct.utmpx** %4
%110 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %109, i32 0, i32 2
%111 = load i8*, i8** %110
%112 = getelementptr inbounds i8, i8* %111, i64 0
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = icmp ne i32 %114, 0
br i1 %115, label %116, label %125
116: ; preds = %108
%117 = load %struct.utmp*, %struct.utmp** %5
%118 = getelementptr inbounds %struct.utmp, %struct.utmp* %117, i32 0, i32 0
%119 = load i8*, i8** %118
%120 = load %struct.utmpx*, %struct.utmpx** %4
%121 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %120, i32 0, i32 2
%122 = load i8*, i8** %121
%123 = load i64, i64* @UT_LINESIZE
%124 = call i32 @strncpy(i8* %119, i8* %122, i64 %123)
br label %133
125: ; preds = %108
%126 = load %struct.utmp*, %struct.utmp** %5
%127 = getelementptr inbounds %struct.utmp, %struct.utmp* %126, i32 0, i32 0
%128 = load i8*, i8** %127
%129 = load %struct.utmpx*, %struct.utmpx** %4
%130 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %129, i32 0, i32 3
%131 = load i8*, i8** %130
%132 = call i32 @strncpy(i8* %128, i8* %131, i64 8)
br label %133
133: ; preds = %125, %116
%134 = load %struct.utmpx*, %struct.utmpx** %4
%135 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %134, i32 0, i32 0
%136 = load i32, i32* %135
switch i32 %136, label %164 [
i32 133, label %137
i32 132, label %143
i32 128, label %149
i32 135, label %158
]
137: ; preds = %133
%138 = load %struct.utmp*, %struct.utmp** %5
%139 = getelementptr inbounds %struct.utmp, %struct.utmp* %138, i32 0, i32 1
%140 = load i8*, i8** %139
%141 = load i64, i64* @UT_NAMESIZE
%142 = call i32 @strncpy(i8* %140, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), i64 %141)
br label %164
143: ; preds = %133
%144 = load %struct.utmp*, %struct.utmp** %5
%145 = getelementptr inbounds %struct.utmp, %struct.utmp* %144, i32 0, i32 1
%146 = load i8*, i8** %145
%147 = load i64, i64* @UT_NAMESIZE
%148 = call i32 @strncpy(i8* %146, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i64 %147)
br label %164
149: ; preds = %133
%150 = load %struct.utmp*, %struct.utmp** %5
%151 = getelementptr inbounds %struct.utmp, %struct.utmp* %150, i32 0, i32 1
%152 = load i8*, i8** %151
%153 = load %struct.utmpx*, %struct.utmpx** %4
%154 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %153, i32 0, i32 4
%155 = load i8*, i8** %154
%156 = load i64, i64* @UT_NAMESIZE
%157 = call i32 @strncpy(i8* %152, i8* %155, i64 %156)
br label %164
158: ; preds = %133
%159 = load %struct.utmp*, %struct.utmp** %5
%160 = getelementptr inbounds %struct.utmp, %struct.utmp* %159, i32 0, i32 1
%161 = load i8*, i8** %160
%162 = load i64, i64* @UT_NAMESIZE
%163 = call i32 @strncpy(i8* %161, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 %162)
br label %164
164: ; preds = %133, %158, %149, %143, %137
%165 = load %struct.utmp*, %struct.utmp** %5
%166 = getelementptr inbounds %struct.utmp, %struct.utmp* %165, i32 0, i32 2
%167 = load i8*, i8** %166
%168 = load %struct.utmpx*, %struct.utmpx** %4
%169 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %168, i32 0, i32 1
%170 = load i8*, i8** %169
%171 = load i32, i32* @UT_HOSTSIZE
%172 = sext i32 %171 to i64
%173 = call i32 @strncpy(i8* %167, i8* %170, i64 %172)
br label %195
174: ; preds = %2
%175 = load %struct.utmp*, %struct.utmp** %5
%176 = getelementptr inbounds %struct.utmp, %struct.utmp* %175, i32 0, i32 0
%177 = load i8*, i8** %176
%178 = load i64, i64* @UT_LINESIZE
%179 = call i32 @strncpy(i8* %177, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 %178)
%180 = load %struct.utmp*, %struct.utmp** %5
%181 = getelementptr inbounds %struct.utmp, %struct.utmp* %180, i32 0, i32 1
%182 = load i8*, i8** %181
%183 = load i64, i64* @UT_NAMESIZE
%184 = call i32 @strncpy(i8* %182, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i64 %183)
%185 = load %struct.utmp*, %struct.utmp** %5
%186 = getelementptr inbounds %struct.utmp, %struct.utmp* %185, i32 0, i32 2
%187 = load i8*, i8** %186
%188 = load %struct.utmpx*, %struct.utmpx** %4
%189 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %188, i32 0, i32 1
%190 = load i8*, i8** %189
%191 = load i32, i32* @UT_HOSTSIZE
%192 = sext i32 %191 to i64
%193 = call i32 @strncpy(i8* %187, i8* %190, i64 %192)
br label %195
194: ; preds = %2
store i32 -1, i32* %3
br label %239
195: ; preds = %174, %164, %88, %68, %48, %28, %11
%196 = load %struct.utmpx*, %struct.utmpx** %4
%197 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %196, i32 0, i32 6
%198 = getelementptr inbounds %struct.TYPE_2__, %struct.TYPE_2__* %197, i32 0, i32 0
%199 = load i32, i32* %198
%200 = load %struct.utmp*, %struct.utmp** %5
%201 = getelementptr inbounds %struct.utmp, %struct.utmp* %200, i32 0, i32 3
store i32 %199, i32* %201
%202 = load %struct.utmpx*, %struct.utmpx** %4
%203 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %202, i32 0, i32 5
%204 = load i64, i64* %203
%205 = icmp ne i64 %204, 0
br i1 %205, label %206, label %238
206: ; preds = %195
%207 = load i32, i32* @UT_HOSTSIZE
%208 = sext i32 %207 to i64
%209 = load %struct.utmp*, %struct.utmp** %5
%210 = getelementptr inbounds %struct.utmp, %struct.utmp* %209, i32 0, i32 2
%211 = load i8*, i8** %210
%212 = call i64 @strlen(i8* %211)
%213 = sub i64 %208, %212
%214 = sub i64 %213, 1
store i64 %214, i64* %7
%215 = getelementptr inbounds [11 x i8], [11 x i8]* %6, i64 0, i64 0
%216 = load %struct.utmpx*, %struct.utmpx** %4
%217 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %216, i32 0, i32 5
%218 = load i64, i64* %217
%219 = call i32 @sprintf(i8* %215, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), i64 %218)
%220 = getelementptr inbounds [11 x i8], [11 x i8]* %6, i64 0, i64 0
%221 = call i64 @strlen(i8* %220)
%222 = load i64, i64* %7
%223 = icmp ule i64 %221, %222
br i1 %223, label %224, label %237
224: ; preds = %206
%225 = load %struct.utmp*, %struct.utmp** %5
%226 = getelementptr inbounds %struct.utmp, %struct.utmp* %225, i32 0, i32 2
%227 = load i8*, i8** %226
%228 = load %struct.utmp*, %struct.utmp** %5
%229 = getelementptr inbounds %struct.utmp, %struct.utmp* %228, i32 0, i32 2
%230 = load i8*, i8** %229
%231 = call i64 @strlen(i8* %230)
%232 = getelementptr inbounds i8, i8* %227, i64 %231
%233 = getelementptr inbounds i8, i8* %232, i64 1
%234 = getelementptr inbounds [11 x i8], [11 x i8]* %6, i64 0, i64 0
%235 = load i64, i64* %7
%236 = call i32 @strncpy(i8* %233, i8* %234, i64 %235)
br label %237
237: ; preds = %224, %206
br label %238
238: ; preds = %237, %195
store i32 0, i32* %3
br label %239
239: ; preds = %238, %194
%240 = load i32, i32* %3
ret i32 %240
}

LLVM IR (-O2):
%struct.utmpx = type { i32, i8*, i8*, i8*, i8*, i64, %struct.TYPE_2__ }
%struct.TYPE_2__ = type { i32 }
%struct.utmp = type { i8*, i8*, i8*, i32 }
@.str = [1 x i8] zeroinitializer
@UT_LINESIZE = global i64 0
@UT_NAMESIZE = global i64 0
@UT_HOSTSIZE = global i32 0
@.str.1 = [2 x i8] c"~\00"
@.str.2 = [9 x i8] c"runlevel\00"
@.str.3 = [7 x i8] c"reboot\00"
@.str.4 = [2 x i8] c"{\00"
@.str.5 = [5 x i8] c"date\00"
@.str.6 = [2 x i8] c"|\00"
@.str.7 = [5 x i8] c"INIT\00"
@.str.8 = [6 x i8] c"LOGIN\00"
@.str.9 = [5 x i8] c"acct\00"
@.str.10 = [4 x i8] c"%lu\00"
define i32 @__utmpx_to_utmp(%struct.utmpx* nocapture %0, %struct.utmp* %1) {
%3 = alloca [11 x i8]
%4 = getelementptr inbounds [11 x i8], [11 x i8]* %3, i64 0, i64 0
%5 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 0
%6 = load i32, i32* %5
switch i32 %6, label %131 [
i32 134, label %7
i32 129, label %16
i32 136, label %27
i32 131, label %38
i32 130, label %49
i32 133, label %60
i32 132, label %60
i32 128, label %60
i32 135, label %60
i32 137, label %90
]
7: ; preds = %2
%8 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 0
%9 = load i8*, i8** %8
%10 = load i64, i64* @UT_LINESIZE
%11 = tail call i32 @strncpy(i8* %9, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 %10)
%12 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 1
%13 = load i8*, i8** %12
%14 = load i64, i64* @UT_NAMESIZE
%15 = tail call i32 @strncpy(i8* %13, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), i64 %14)
br label %101
16: ; preds = %2
%17 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 0
%18 = load i8*, i8** %17
%19 = load i64, i64* @UT_LINESIZE
%20 = tail call i32 @strncpy(i8* %18, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 %19)
%21 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 1
%22 = load i8*, i8** %21
%23 = load i64, i64* @UT_NAMESIZE
%24 = tail call i32 @strncpy(i8* %22, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i64 %23)
%25 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 1
%26 = load i8*, i8** %25
br label %101
27: ; preds = %2
%28 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 0
%29 = load i8*, i8** %28
%30 = load i64, i64* @UT_LINESIZE
%31 = tail call i32 @strncpy(i8* %29, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 %30)
%32 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 1
%33 = load i8*, i8** %32
%34 = load i64, i64* @UT_NAMESIZE
%35 = tail call i32 @strncpy(i8* %33, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i64 %34)
%36 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 1
%37 = load i8*, i8** %36
br label %101
38: ; preds = %2
%39 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 0
%40 = load i8*, i8** %39
%41 = load i64, i64* @UT_LINESIZE
%42 = tail call i32 @strncpy(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i64 %41)
%43 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 1
%44 = load i8*, i8** %43
%45 = load i64, i64* @UT_NAMESIZE
%46 = tail call i32 @strncpy(i8* %44, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i64 %45)
%47 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 1
%48 = load i8*, i8** %47
br label %101
49: ; preds = %2
%50 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 0
%51 = load i8*, i8** %50
%52 = load i64, i64* @UT_LINESIZE
%53 = tail call i32 @strncpy(i8* %51, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0), i64 %52)
%54 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 1
%55 = load i8*, i8** %54
%56 = load i64, i64* @UT_NAMESIZE
%57 = tail call i32 @strncpy(i8* %55, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i64 %56)
%58 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 1
%59 = load i8*, i8** %58
br label %101
60: ; preds = %2, %2, %2, %2
%61 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 2
%62 = load i8*, i8** %61
%63 = load i8, i8* %62
%64 = icmp eq i8 %63, 0
%65 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 0
%66 = load i8*, i8** %65
br i1 %64, label %70, label %67
67: ; preds = %60
%68 = load i64, i64* @UT_LINESIZE
%69 = tail call i32 @strncpy(i8* %66, i8* %62, i64 %68)
br label %74
70: ; preds = %60
%71 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 3
%72 = load i8*, i8** %71
%73 = tail call i32 @strncpy(i8* %66, i8* %72, i64 8)
br label %74
74: ; preds = %70, %67
%75 = load i32, i32* %5
switch i32 %75, label %87 [
i32 133, label %81
i32 132, label %76
i32 128, label %77
i32 135, label %80
]
76: ; preds = %74
br label %81
77: ; preds = %74
%78 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 4
%79 = load i8*, i8** %78
br label %81
80: ; preds = %74
br label %81
81: ; preds = %74, %76, %77, %80
%82 = phi i8* [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), %80 ], [ %79, %77 ], [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), %76 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0), %74 ]
%83 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 1
%84 = load i8*, i8** %83
%85 = load i64, i64* @UT_NAMESIZE
%86 = tail call i32 @strncpy(i8* %84, i8* %82, i64 %85)
br label %87
87: ; preds = %81, %74
%88 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 1
%89 = load i8*, i8** %88
br label %101
90: ; preds = %2
%91 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 0
%92 = load i8*, i8** %91
%93 = load i64, i64* @UT_LINESIZE
%94 = tail call i32 @strncpy(i8* %92, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i64 %93)
%95 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 1
%96 = load i8*, i8** %95
%97 = load i64, i64* @UT_NAMESIZE
%98 = tail call i32 @strncpy(i8* %96, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i64 %97)
%99 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 1
%100 = load i8*, i8** %99
br label %101
101: ; preds = %90, %87, %49, %38, %27, %16, %7
%102 = phi i8* [ %100, %90 ], [ %89, %87 ], [ %59, %49 ], [ %48, %38 ], [ %37, %27 ], [ %26, %16 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0), %7 ]
%103 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 2
%104 = load i8*, i8** %103
%105 = load i32, i32* @UT_HOSTSIZE
%106 = sext i32 %105 to i64
%107 = tail call i32 @strncpy(i8* %104, i8* %102, i64 %106)
%108 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 6, i32 0
%109 = load i32, i32* %108
%110 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 3
store i32 %109, i32* %110
%111 = getelementptr inbounds %struct.utmpx, %struct.utmpx* %0, i64 0, i32 5
%112 = load i64, i64* %111
%113 = icmp eq i64 %112, 0
br i1 %113, label %131, label %114
114: ; preds = %101
%115 = load i32, i32* @UT_HOSTSIZE
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds %struct.utmp, %struct.utmp* %1, i64 0, i32 2
%118 = load i8*, i8** %117
%119 = tail call i64 @strlen(i8* dereferenceable(1) %118)
%120 = xor i64 %119, -1
%121 = add i64 %120, %116
%122 = call i32 @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), i64 %112)
%123 = call i64 @strlen(i8* %4)
%124 = icmp ugt i64 %123, %121
br i1 %124, label %131, label %125
125: ; preds = %114
%126 = load i8*, i8** %117
%127 = tail call i64 @strlen(i8* dereferenceable(1) %126)
%128 = getelementptr inbounds i8, i8* %126, i64 %127
%129 = getelementptr inbounds i8, i8* %128, i64 1
%130 = call i32 @strncpy(i8* %129, i8* %4, i64 %121)
br label %131
131: ; preds = %101, %125, %114, %2
%132 = phi i32 [ -1, %2 ], [ 0, %114 ], [ 0, %125 ], [ 0, %101 ]
ret i32 %132
}