#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 _split(char *, char, char ***);
scalar_t__ malloc(int);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
char *parseInt2String(int);
int /*<<< orphan*/ perror(char *);
int strlen(char *);
char *_transfer_ip_port_str(char *ip, int port) {
  int i, j, l;
  char **ips = NULL;
  l = _split(ip, '.', &ips);
  if (l != 4) {
    perror("ip format is wrong");
  }
  char *buf = (char *)malloc(sizeof(char) * 30);
  memset(buf, 0, sizeof(char) * 30);
  int curIndex = 0;
  for (i = 0; i < 4; i++) {
    l = strlen(ips[i]);
    for (j = 0; j < l; j++) {
      buf[curIndex++] = ips[i][j];
    }
    buf[curIndex++] = ',';
  }
  char *a = parseInt2String(port / 256);
  for (i = 0; i < strlen(a); i++) {
    buf[curIndex++] = a[i];
  }
  buf[curIndex++] = ',';
  char *b = parseInt2String(port % 256);
  for (i = 0; i < strlen(b); i++) {
    buf[curIndex++] = b[i];
  }
  return buf;
}


x86 assembly (clang, -O0):
<_transfer_ip_port_str>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
mov    $0x2e,%esi
lea    -0x20(%rbp),%rdx
call   1030 <_split@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
je     11a2 <_transfer_ip_port_str+0x42>
lea    0xe63(%rip),%rdi
call   1080 <perror@plt>
mov    $0x1e,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x1e,%edx
call   1050 <memset@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x4,-0x10(%rbp)
jge    1259 <_transfer_ip_port_str+0xf9>
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1235 <_transfer_ip_port_str+0xd5>
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11f3 <_transfer_ip_port_str+0x93>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x2c,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11ce <_transfer_ip_port_str+0x6e>
mov    -0xc(%rbp),%eax
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
call   1070 <parseInt2String@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
cmp    %ecx,%eax
jge    12c0 <_transfer_ip_port_str+0x160>
mov    -0x38(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1276 <_transfer_ip_port_str+0x116>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x2c,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %edx,%edi
call   1070 <parseInt2String@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%eax
cmp    %ecx,%eax
jge    133d <_transfer_ip_port_str+0x1dd>
mov    -0x40(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12f3 <_transfer_ip_port_str+0x193>
mov    -0x28(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_transfer_ip_port_str>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r14d
movq   $0x0,(%rsp)
mov    %rsp,%rdx
mov    $0x2e,%esi
call   1030 <_split@plt>
cmp    $0x4,%eax
jne    148d <_transfer_ip_port_str+0x32d>
mov    $0x1e,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
xor    %r12d,%r12d
mov    %rax,%rdi
xor    %esi,%esi
mov    $0x1e,%edx
call   1050 <memset@plt>
mov    (%rsp),%rax
mov    (%rax),%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    124c <_transfer_ip_port_str+0xec>
mov    %eax,%esi
lea    -0x1(%rsi),%rdx
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    11d4 <_transfer_ip_port_str+0x74>
xor    %edx,%edx
jmp    122b <_transfer_ip_port_str+0xcb>
and    $0xfffffffc,%esi
xor    %edx,%edx
nopl   0x0(%rax)
mov    (%rsp),%rdi
mov    (%rdi),%rdi
movzbl (%rdi,%rdx,1),%ebx
mov    %bl,(%r15,%rdx,1)
mov    (%rsp),%rdi
mov    (%rdi),%rdi
movzbl 0x1(%rdi,%rdx,1),%ebx
mov    %bl,0x1(%r15,%rdx,1)
mov    (%rsp),%rdi
mov    (%rdi),%rdi
movzbl 0x2(%rdi,%rdx,1),%ebx
mov    %bl,0x2(%r15,%rdx,1)
mov    (%rsp),%rdi
mov    (%rdi),%rdi
movzbl 0x3(%rdi,%rdx,1),%ebx
mov    %bl,0x3(%r15,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    11e0 <_transfer_ip_port_str+0x80>
test   %rcx,%rcx
je     1249 <_transfer_ip_port_str+0xe9>
mov    (%rsp),%rsi
mov    (%rsi),%rsi
movzbl (%rsi,%rdx,1),%ebx
mov    %bl,(%r15,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1230 <_transfer_ip_port_str+0xd0>
mov    %eax,%r12d
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x2c,(%r15,%rax,1)
mov    (%rsp),%rax
mov    0x8(%rax),%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    12c7 <_transfer_ip_port_str+0x167>
movslq %r12d,%r12
mov    %eax,%ecx
cmp    $0x1,%eax
jne    1277 <_transfer_ip_port_str+0x117>
xor    %eax,%eax
jmp    12af <_transfer_ip_port_str+0x14f>
mov    %ecx,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
xchg   %ax,%ax
mov    (%rsp),%rsi
mov    0x8(%rsi),%rsi
movzbl (%rsi,%rax,1),%ebx
mov    %bl,(%r15,%r12,1)
mov    (%rsp),%rsi
mov    0x8(%rsi),%rsi
movzbl 0x1(%rsi,%rax,1),%ebx
mov    %bl,0x1(%r15,%r12,1)
add    $0x2,%r12
add    $0x2,%rax
cmp    %rax,%rdx
jne    1280 <_transfer_ip_port_str+0x120>
test   $0x1,%cl
je     12c7 <_transfer_ip_port_str+0x167>
mov    (%rsp),%rcx
mov    0x8(%rcx),%rcx
mov    (%rcx,%rax,1),%al
mov    %al,(%r15,%r12,1)
add    $0x1,%r12
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x2c,(%r15,%rax,1)
mov    (%rsp),%rax
mov    0x10(%rax),%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1347 <_transfer_ip_port_str+0x1e7>
movslq %r12d,%r12
mov    %eax,%ecx
cmp    $0x1,%eax
jne    12f2 <_transfer_ip_port_str+0x192>
xor    %eax,%eax
jmp    132f <_transfer_ip_port_str+0x1cf>
mov    %ecx,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
nopl   0x0(%rax)
mov    (%rsp),%rsi
mov    0x10(%rsi),%rsi
movzbl (%rsi,%rax,1),%ebx
mov    %bl,(%r15,%r12,1)
mov    (%rsp),%rsi
mov    0x10(%rsi),%rsi
movzbl 0x1(%rsi,%rax,1),%ebx
mov    %bl,0x1(%r15,%r12,1)
add    $0x2,%r12
add    $0x2,%rax
cmp    %rax,%rdx
jne    1300 <_transfer_ip_port_str+0x1a0>
test   $0x1,%cl
je     1347 <_transfer_ip_port_str+0x1e7>
mov    (%rsp),%rcx
mov    0x10(%rcx),%rcx
mov    (%rcx,%rax,1),%al
mov    %al,(%r15,%r12,1)
add    $0x1,%r12
movslq %r12d,%rax
add    $0x1,%r12d
movb   $0x2c,(%r15,%rax,1)
mov    (%rsp),%rax
mov    0x18(%rax),%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    13c7 <_transfer_ip_port_str+0x267>
movslq %r12d,%r12
mov    %eax,%ecx
cmp    $0x1,%eax
jne    1372 <_transfer_ip_port_str+0x212>
xor    %eax,%eax
jmp    13af <_transfer_ip_port_str+0x24f>
mov    %ecx,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
nopl   0x0(%rax)
mov    (%rsp),%rsi
mov    0x18(%rsi),%rsi
movzbl (%rsi,%rax,1),%ebx
mov    %bl,(%r15,%r12,1)
mov    (%rsp),%rsi
mov    0x18(%rsi),%rsi
movzbl 0x1(%rsi,%rax,1),%ebx
mov    %bl,0x1(%r15,%r12,1)
add    $0x2,%r12
add    $0x2,%rax
cmp    %rax,%rdx
jne    1380 <_transfer_ip_port_str+0x220>
test   $0x1,%cl
je     13c7 <_transfer_ip_port_str+0x267>
mov    (%rsp),%rcx
mov    0x18(%rcx),%rcx
mov    (%rcx,%rax,1),%al
mov    %al,(%r15,%r12,1)
add    $0x1,%r12
movslq %r12d,%rax
add    $0x1,%r12d
lea    0xff(%r14),%edi
test   %r14d,%r14d
cmovns %r14d,%edi
movb   $0x2c,(%r15,%rax,1)
mov    %edi,%eax
and    $0xffffff00,%eax
sub    %eax,%r14d
sar    $0x8,%edi
call   1070 <parseInt2String@plt>
mov    %rax,%r13
mov    %rax,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1430 <_transfer_ip_port_str+0x2d0>
movslq %r12d,%rbp
add    %r15,%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rbx,1),%eax
mov    %al,0x0(%rbp,%rbx,1)
add    $0x1,%rbx
mov    %r13,%rdi
call   1040 <strlen@plt>
cltq
cmp    %rax,%rbx
jl     1410 <_transfer_ip_port_str+0x2b0>
add    %ebx,%r12d
movslq %r12d,%rbp
movb   $0x2c,(%r15,%rbp,1)
mov    %r14d,%edi
call   1070 <parseInt2String@plt>
mov    %rax,%rbx
mov    %rax,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    147b <_transfer_ip_port_str+0x31b>
lea    (%r15,%rbp,1),%r14
add    $0x1,%r14
xor    %ebp,%ebp
nopl   0x0(%rax)
movzbl (%rbx,%rbp,1),%eax
mov    %al,(%r14,%rbp,1)
add    $0x1,%rbp
mov    %rbx,%rdi
call   1040 <strlen@plt>
cltq
cmp    %rax,%rbp
jl     1460 <_transfer_ip_port_str+0x300>
mov    %r15,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xb6c(%rip),%rdi
call   1080 <perror@plt>
jmp    118c <_transfer_ip_port_str+0x2c>

LLVM IR (-O0):
@.str = [19 x i8] c"ip format is wrong\00"
define i8* @_transfer_ip_port_str(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i8*
store i8* %0, i8** %3
store i32 %1, i32* %4
store i8** null, i8*** %8
%13 = load i8*, i8** %3
%14 = call i32 @_split(i8* %13, i8 signext 46, i8*** %8)
store i32 %14, i32* %7
%15 = load i32, i32* %7
%16 = icmp ne i32 %15, 4
br i1 %16, label %17, label %19
17: ; preds = %2
%18 = call i32 @perror(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
br label %19
19: ; preds = %17, %2
%20 = call i64 @malloc(i32 30)
%21 = inttoptr i64 %20 to i8*
store i8* %21, i8** %9
%22 = load i8*, i8** %9
%23 = call i32 @memset(i8* %22, i32 0, i32 30)
store i32 0, i32* %10
store i32 0, i32* %5
br label %24
24: ; preds = %62, %19
%25 = load i32, i32* %5
%26 = icmp slt i32 %25, 4
br i1 %26, label %27, label %65
27: ; preds = %24
%28 = load i8**, i8*** %8
%29 = load i32, i32* %5
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8*, i8** %28, i64 %30
%32 = load i8*, i8** %31
%33 = call i32 @strlen(i8* %32)
store i32 %33, i32* %7
store i32 0, i32* %6
br label %34
34: ; preds = %53, %27
%35 = load i32, i32* %6
%36 = load i32, i32* %7
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %56
38: ; preds = %34
%39 = load i8**, i8*** %8
%40 = load i32, i32* %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8*, i8** %39, i64 %41
%43 = load i8*, i8** %42
%44 = load i32, i32* %6
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
%47 = load i8, i8* %46
%48 = load i8*, i8** %9
%49 = load i32, i32* %10
%50 = add nsw i32 %49, 1
store i32 %50, i32* %10
%51 = sext i32 %49 to i64
%52 = getelementptr inbounds i8, i8* %48, i64 %51
store i8 %47, i8* %52
br label %53
53: ; preds = %38
%54 = load i32, i32* %6
%55 = add nsw i32 %54, 1
store i32 %55, i32* %6
br label %34
56: ; preds = %34
%57 = load i8*, i8** %9
%58 = load i32, i32* %10
%59 = add nsw i32 %58, 1
store i32 %59, i32* %10
%60 = sext i32 %58 to i64
%61 = getelementptr inbounds i8, i8* %57, i64 %60
store i8 44, i8* %61
br label %62
62: ; preds = %56
%63 = load i32, i32* %5
%64 = add nsw i32 %63, 1
store i32 %64, i32* %5
br label %24
65: ; preds = %24
%66 = load i32, i32* %4
%67 = sdiv i32 %66, 256
%68 = call i8* @parseInt2String(i32 %67)
store i8* %68, i8** %11
store i32 0, i32* %5
br label %69
69: ; preds = %85, %65
%70 = load i32, i32* %5
%71 = load i8*, i8** %11
%72 = call i32 @strlen(i8* %71)
%73 = icmp slt i32 %70, %72
br i1 %73, label %74, label %88
74: ; preds = %69
%75 = load i8*, i8** %11
%76 = load i32, i32* %5
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %75, i64 %77
%79 = load i8, i8* %78
%80 = load i8*, i8** %9
%81 = load i32, i32* %10
%82 = add nsw i32 %81, 1
store i32 %82, i32* %10
%83 = sext i32 %81 to i64
%84 = getelementptr inbounds i8, i8* %80, i64 %83
store i8 %79, i8* %84
br label %85
85: ; preds = %74
%86 = load i32, i32* %5
%87 = add nsw i32 %86, 1
store i32 %87, i32* %5
br label %69
88: ; preds = %69
%89 = load i8*, i8** %9
%90 = load i32, i32* %10
%91 = add nsw i32 %90, 1
store i32 %91, i32* %10
%92 = sext i32 %90 to i64
%93 = getelementptr inbounds i8, i8* %89, i64 %92
store i8 44, i8* %93
%94 = load i32, i32* %4
%95 = srem i32 %94, 256
%96 = call i8* @parseInt2String(i32 %95)
store i8* %96, i8** %12
store i32 0, i32* %5
br label %97
97: ; preds = %113, %88
%98 = load i32, i32* %5
%99 = load i8*, i8** %12
%100 = call i32 @strlen(i8* %99)
%101 = icmp slt i32 %98, %100
br i1 %101, label %102, label %116
102: ; preds = %97
%103 = load i8*, i8** %12
%104 = load i32, i32* %5
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %103, i64 %105
%107 = load i8, i8* %106
%108 = load i8*, i8** %9
%109 = load i32, i32* %10
%110 = add nsw i32 %109, 1
store i32 %110, i32* %10
%111 = sext i32 %109 to i64
%112 = getelementptr inbounds i8, i8* %108, i64 %111
store i8 %107, i8* %112
br label %113
113: ; preds = %102
%114 = load i32, i32* %5
%115 = add nsw i32 %114, 1
store i32 %115, i32* %5
br label %97
116: ; preds = %97
%117 = load i8*, i8** %9
ret i8* %117
}

LLVM IR (-O2):
@.str = [19 x i8] c"ip format is wrong\00"
define i8* @_transfer_ip_port_str(i8* %0, i32 %1) {
%3 = alloca i8**
%4 = bitcast i8*** %3 to i8*
store i8** null, i8*** %3
%5 = call i32 @_split(i8* %0, i8 signext 46, i8*** %3)
%6 = icmp eq i32 %5, 4
br i1 %6, label %9, label %7
7: ; preds = %2
%8 = call i32 @perror(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
br label %9
9: ; preds = %7, %2
%10 = call i64 @malloc(i32 30)
%11 = inttoptr i64 %10 to i8*
%12 = call i32 @memset(i8* %11, i32 0, i32 30)
%13 = load i8**, i8*** %3
%14 = load i8*, i8** %13
%15 = call i32 @strlen(i8* %14)
%16 = icmp sgt i32 %15, 0
br i1 %16, label %17, label %67
17: ; preds = %9
%18 = zext i32 %15 to i64
%19 = add nsw i64 %18, -1
%20 = and i64 %18, 3
%21 = icmp ult i64 %19, 3
br i1 %21, label %53, label %22
22: ; preds = %17
%23 = and i64 %18, 4294967292
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %49, %24 ]
%26 = phi i64 [ 0, %22 ], [ %51, %24 ]
%27 = load i8**, i8*** %3
%28 = load i8*, i8** %27
%29 = getelementptr inbounds i8, i8* %28, i64 %25
%30 = load i8, i8* %29
%31 = or i64 %25, 1
%32 = getelementptr inbounds i8, i8* %11, i64 %25
store i8 %30, i8* %32
%33 = load i8**, i8*** %3
%34 = load i8*, i8** %33
%35 = getelementptr inbounds i8, i8* %34, i64 %31
%36 = load i8, i8* %35
%37 = or i64 %25, 2
%38 = getelementptr inbounds i8, i8* %11, i64 %31
store i8 %36, i8* %38
%39 = load i8**, i8*** %3
%40 = load i8*, i8** %39
%41 = getelementptr inbounds i8, i8* %40, i64 %37
%42 = load i8, i8* %41
%43 = or i64 %25, 3
%44 = getelementptr inbounds i8, i8* %11, i64 %37
store i8 %42, i8* %44
%45 = load i8**, i8*** %3
%46 = load i8*, i8** %45
%47 = getelementptr inbounds i8, i8* %46, i64 %43
%48 = load i8, i8* %47
%49 = add nuw nsw i64 %25, 4
%50 = getelementptr inbounds i8, i8* %11, i64 %43
store i8 %48, i8* %50
%51 = add i64 %26, 4
%52 = icmp eq i64 %51, %23
br i1 %52, label %53, label %24
53: ; preds = %24, %17
%54 = phi i64 [ 0, %17 ], [ %49, %24 ]
%55 = icmp eq i64 %20, 0
br i1 %55, label %67, label %56
56: ; preds = %53, %56
%57 = phi i64 [ %63, %56 ], [ %54, %53 ]
%58 = phi i64 [ %65, %56 ], [ 0, %53 ]
%59 = load i8**, i8*** %3
%60 = load i8*, i8** %59
%61 = getelementptr inbounds i8, i8* %60, i64 %57
%62 = load i8, i8* %61
%63 = add nuw nsw i64 %57, 1
%64 = getelementptr inbounds i8, i8* %11, i64 %57
store i8 %62, i8* %64
%65 = add i64 %58, 1
%66 = icmp eq i64 %65, %20
br i1 %66, label %67, label %56
67: ; preds = %53, %56, %9
%68 = phi i32 [ 0, %9 ], [ %15, %56 ], [ %15, %53 ]
%69 = add nsw i32 %68, 1
%70 = sext i32 %68 to i64
%71 = getelementptr inbounds i8, i8* %11, i64 %70
store i8 44, i8* %71
%72 = load i8**, i8*** %3
%73 = getelementptr inbounds i8*, i8** %72, i64 1
%74 = load i8*, i8** %73
%75 = call i32 @strlen(i8* %74)
%76 = icmp sgt i32 %75, 0
br i1 %76, label %77, label %122
77: ; preds = %67
%78 = sext i32 %69 to i64
%79 = zext i32 %75 to i64
%80 = and i64 %79, 1
%81 = icmp eq i32 %75, 1
br i1 %81, label %106, label %82
82: ; preds = %77
%83 = and i64 %79, 4294967294
br label %84
84: ; preds = %84, %82
%85 = phi i64 [ %78, %82 ], [ %101, %84 ]
%86 = phi i64 [ 0, %82 ], [ %103, %84 ]
%87 = phi i64 [ 0, %82 ], [ %104, %84 ]
%88 = load i8**, i8*** %3
%89 = getelementptr inbounds i8*, i8** %88, i64 1
%90 = load i8*, i8** %89
%91 = getelementptr inbounds i8, i8* %90, i64 %86
%92 = load i8, i8* %91
%93 = add nsw i64 %85, 1
%94 = getelementptr inbounds i8, i8* %11, i64 %85
store i8 %92, i8* %94
%95 = or i64 %86, 1
%96 = load i8**, i8*** %3
%97 = getelementptr inbounds i8*, i8** %96, i64 1
%98 = load i8*, i8** %97
%99 = getelementptr inbounds i8, i8* %98, i64 %95
%100 = load i8, i8* %99
%101 = add nsw i64 %85, 2
%102 = getelementptr inbounds i8, i8* %11, i64 %93
store i8 %100, i8* %102
%103 = add nuw nsw i64 %86, 2
%104 = add i64 %87, 2
%105 = icmp eq i64 %104, %83
br i1 %105, label %106, label %84
106: ; preds = %84, %77
%107 = phi i64 [ undef, %77 ], [ %101, %84 ]
%108 = phi i64 [ %78, %77 ], [ %101, %84 ]
%109 = phi i64 [ 0, %77 ], [ %103, %84 ]
%110 = icmp eq i64 %80, 0
br i1 %110, label %119, label %111
111: ; preds = %106
%112 = load i8**, i8*** %3
%113 = getelementptr inbounds i8*, i8** %112, i64 1
%114 = load i8*, i8** %113
%115 = getelementptr inbounds i8, i8* %114, i64 %109
%116 = load i8, i8* %115
%117 = add nsw i64 %108, 1
%118 = getelementptr inbounds i8, i8* %11, i64 %108
store i8 %116, i8* %118
br label %119
119: ; preds = %106, %111
%120 = phi i64 [ %107, %106 ], [ %117, %111 ]
%121 = trunc i64 %120 to i32
br label %122
122: ; preds = %119, %67
%123 = phi i32 [ %69, %67 ], [ %121, %119 ]
%124 = add nsw i32 %123, 1
%125 = sext i32 %123 to i64
%126 = getelementptr inbounds i8, i8* %11, i64 %125
store i8 44, i8* %126
%127 = load i8**, i8*** %3
%128 = getelementptr inbounds i8*, i8** %127, i64 2
%129 = load i8*, i8** %128
%130 = call i32 @strlen(i8* %129)
%131 = icmp sgt i32 %130, 0
br i1 %131, label %132, label %177
132: ; preds = %122
%133 = sext i32 %124 to i64
%134 = zext i32 %130 to i64
%135 = and i64 %134, 1
%136 = icmp eq i32 %130, 1
br i1 %136, label %161, label %137
137: ; preds = %132
%138 = and i64 %134, 4294967294
br label %139
139: ; preds = %139, %137
%140 = phi i64 [ %133, %137 ], [ %156, %139 ]
%141 = phi i64 [ 0, %137 ], [ %158, %139 ]
%142 = phi i64 [ 0, %137 ], [ %159, %139 ]
%143 = load i8**, i8*** %3
%144 = getelementptr inbounds i8*, i8** %143, i64 2
%145 = load i8*, i8** %144
%146 = getelementptr inbounds i8, i8* %145, i64 %141
%147 = load i8, i8* %146
%148 = add nsw i64 %140, 1
%149 = getelementptr inbounds i8, i8* %11, i64 %140
store i8 %147, i8* %149
%150 = or i64 %141, 1
%151 = load i8**, i8*** %3
%152 = getelementptr inbounds i8*, i8** %151, i64 2
%153 = load i8*, i8** %152
%154 = getelementptr inbounds i8, i8* %153, i64 %150
%155 = load i8, i8* %154
%156 = add nsw i64 %140, 2
%157 = getelementptr inbounds i8, i8* %11, i64 %148
store i8 %155, i8* %157
%158 = add nuw nsw i64 %141, 2
%159 = add i64 %142, 2
%160 = icmp eq i64 %159, %138
br i1 %160, label %161, label %139
161: ; preds = %139, %132
%162 = phi i64 [ undef, %132 ], [ %156, %139 ]
%163 = phi i64 [ %133, %132 ], [ %156, %139 ]
%164 = phi i64 [ 0, %132 ], [ %158, %139 ]
%165 = icmp eq i64 %135, 0
br i1 %165, label %174, label %166
166: ; preds = %161
%167 = load i8**, i8*** %3
%168 = getelementptr inbounds i8*, i8** %167, i64 2
%169 = load i8*, i8** %168
%170 = getelementptr inbounds i8, i8* %169, i64 %164
%171 = load i8, i8* %170
%172 = add nsw i64 %163, 1
%173 = getelementptr inbounds i8, i8* %11, i64 %163
store i8 %171, i8* %173
br label %174
174: ; preds = %161, %166
%175 = phi i64 [ %162, %161 ], [ %172, %166 ]
%176 = trunc i64 %175 to i32
br label %177
177: ; preds = %174, %122
%178 = phi i32 [ %124, %122 ], [ %176, %174 ]
%179 = add nsw i32 %178, 1
%180 = sext i32 %178 to i64
%181 = getelementptr inbounds i8, i8* %11, i64 %180
store i8 44, i8* %181
%182 = load i8**, i8*** %3
%183 = getelementptr inbounds i8*, i8** %182, i64 3
%184 = load i8*, i8** %183
%185 = call i32 @strlen(i8* %184)
%186 = icmp sgt i32 %185, 0
br i1 %186, label %187, label %232
187: ; preds = %177
%188 = sext i32 %179 to i64
%189 = zext i32 %185 to i64
%190 = and i64 %189, 1
%191 = icmp eq i32 %185, 1
br i1 %191, label %216, label %192
192: ; preds = %187
%193 = and i64 %189, 4294967294
br label %194
194: ; preds = %194, %192
%195 = phi i64 [ %188, %192 ], [ %211, %194 ]
%196 = phi i64 [ 0, %192 ], [ %213, %194 ]
%197 = phi i64 [ 0, %192 ], [ %214, %194 ]
%198 = load i8**, i8*** %3
%199 = getelementptr inbounds i8*, i8** %198, i64 3
%200 = load i8*, i8** %199
%201 = getelementptr inbounds i8, i8* %200, i64 %196
%202 = load i8, i8* %201
%203 = add nsw i64 %195, 1
%204 = getelementptr inbounds i8, i8* %11, i64 %195
store i8 %202, i8* %204
%205 = or i64 %196, 1
%206 = load i8**, i8*** %3
%207 = getelementptr inbounds i8*, i8** %206, i64 3
%208 = load i8*, i8** %207
%209 = getelementptr inbounds i8, i8* %208, i64 %205
%210 = load i8, i8* %209
%211 = add nsw i64 %195, 2
%212 = getelementptr inbounds i8, i8* %11, i64 %203
store i8 %210, i8* %212
%213 = add nuw nsw i64 %196, 2
%214 = add i64 %197, 2
%215 = icmp eq i64 %214, %193
br i1 %215, label %216, label %194
216: ; preds = %194, %187
%217 = phi i64 [ undef, %187 ], [ %211, %194 ]
%218 = phi i64 [ %188, %187 ], [ %211, %194 ]
%219 = phi i64 [ 0, %187 ], [ %213, %194 ]
%220 = icmp eq i64 %190, 0
br i1 %220, label %229, label %221
221: ; preds = %216
%222 = load i8**, i8*** %3
%223 = getelementptr inbounds i8*, i8** %222, i64 3
%224 = load i8*, i8** %223
%225 = getelementptr inbounds i8, i8* %224, i64 %219
%226 = load i8, i8* %225
%227 = add nsw i64 %218, 1
%228 = getelementptr inbounds i8, i8* %11, i64 %218
store i8 %226, i8* %228
br label %229
229: ; preds = %216, %221
%230 = phi i64 [ %217, %216 ], [ %227, %221 ]
%231 = trunc i64 %230 to i32
br label %232
232: ; preds = %229, %177
%233 = phi i32 [ %179, %177 ], [ %231, %229 ]
%234 = add i32 %233, 1
%235 = sext i32 %233 to i64
%236 = getelementptr inbounds i8, i8* %11, i64 %235
store i8 44, i8* %236
%237 = sdiv i32 %1, 256
%238 = srem i32 %1, 256
%239 = call i8* @parseInt2String(i32 %237)
%240 = call i32 @strlen(i8* %239)
%241 = icmp sgt i32 %240, 0
br i1 %241, label %242, label %257
242: ; preds = %232
%243 = sext i32 %234 to i64
br label %244
244: ; preds = %242, %244
%245 = phi i64 [ %243, %242 ], [ %249, %244 ]
%246 = phi i64 [ 0, %242 ], [ %251, %244 ]
%247 = getelementptr inbounds i8, i8* %239, i64 %246
%248 = load i8, i8* %247
%249 = add nsw i64 %245, 1
%250 = getelementptr inbounds i8, i8* %11, i64 %245
store i8 %248, i8* %250
%251 = add nuw nsw i64 %246, 1
%252 = call i32 @strlen(i8* %239)
%253 = sext i32 %252 to i64
%254 = icmp slt i64 %251, %253
br i1 %254, label %244, label %255
255: ; preds = %244
%256 = trunc i64 %249 to i32
br label %257
257: ; preds = %255, %232
%258 = phi i32 [ %234, %232 ], [ %256, %255 ]
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8, i8* %11, i64 %259
store i8 44, i8* %260
%261 = call i8* @parseInt2String(i32 %238)
%262 = call i32 @strlen(i8* %261)
%263 = icmp sgt i32 %262, 0
br i1 %263, label %264, label %275
264: ; preds = %257, %264
%265 = phi i64 [ %271, %264 ], [ 0, %257 ]
%266 = phi i64 [ %267, %264 ], [ %259, %257 ]
%267 = add nsw i64 %266, 1
%268 = getelementptr inbounds i8, i8* %261, i64 %265
%269 = load i8, i8* %268
%270 = getelementptr inbounds i8, i8* %11, i64 %267
store i8 %269, i8* %270
%271 = add nuw nsw i64 %265, 1
%272 = call i32 @strlen(i8* %261)
%273 = sext i32 %272 to i64
%274 = icmp slt i64 %271, %273
br i1 %274, label %264, label %275
275: ; preds = %264, %257
ret i8* %11
}