char *inet_ntoa(unsigned long addr) {
  static char str[16];
  char inv[3];
  char *rp;
  unsigned char *ap;
  unsigned char rem;
  unsigned char n;
  unsigned char i;
  rp = str;
  ap = (unsigned char *)&addr;
  for (n = 0; n < 4; n++) {
    i = 0;
    do {
      rem = *ap % (unsigned char)10;
      *ap /= (unsigned char)10;
      inv[i++] = '0' + rem;
    } while (*ap);
    while (i--)
      *rp++ = inv[i];
    *rp++ = '.';
    ap++;
  }
  *--rp = 0;
  return str;
}


x86 assembly (clang, -O0):
<inet_ntoa>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
lea    0x2f21(%rip),%rax
mov    %rax,-0x18(%rbp)
lea    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movb   $0x0,-0x22(%rbp)
movzbl -0x22(%rbp),%eax
cmp    $0x4,%eax
jge    11e8 <inet_ntoa+0xe8>
movb   $0x0,-0x23(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %dl,%al
mov    %al,-0x21(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
movzbl (%rax),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
movzbl -0x21(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x23(%rbp),%al
mov    %al,%dl
add    $0x1,%dl
mov    %dl,-0x23(%rbp)
movzbl %al,%eax
mov    %cl,-0xb(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1130 <inet_ntoa+0x30>
jmp    118c <inet_ntoa+0x8c>
mov    -0x23(%rbp),%al
mov    %al,%cl
add    $0xff,%cl
mov    %cl,-0x23(%rbp)
cmp    $0x0,%al
je     11bd <inet_ntoa+0xbd>
movzbl -0x23(%rbp),%eax
mov    -0xb(%rbp,%rax,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    118c <inet_ntoa+0x8c>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x2e,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x22(%rbp),%al
add    $0x1,%al
mov    %al,-0x22(%rbp)
jmp    111f <inet_ntoa+0x1f>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x0,-0x1(%rax)
lea    0x2e2e(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<inet_ntoa>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rdx
shr    $0x8,%rdx
mov    %rdi,%r15
shr    $0x10,%r15
mov    %rdi,%r10
shr    $0x18,%r10
xor    %eax,%eax
nopl   0x0(%rax)
movzbl %dil,%ecx
imul   $0xcd,%ecx,%edi
shr    $0xb,%edi
lea    (%rdi,%rdi,1),%esi
lea    (%rsi,%rsi,4),%esi
mov    %ecx,%ebx
sub    %sil,%bl
or     $0x30,%bl
movzbl %al,%esi
add    $0x1,%al
mov    %bl,-0x3(%rsp,%rsi,1)
cmp    $0x9,%cl
ja     1120 <inet_ntoa+0x20>
sub    $0x1,%al
jae    1159 <inet_ntoa+0x59>
lea    0x2edc(%rip),%r9
jmp    1262 <inet_ntoa+0x162>
mov    %bl,0x2ed1(%rip)
jne    116d <inet_ntoa+0x6d>
lea    0x2ec9(%rip),%r9
jmp    1262 <inet_ntoa+0x162>
lea    -0x1(%rsi),%rdi
cmp    $0x20,%al
jae    1181 <inet_ntoa+0x81>
lea    0x2eb5(%rip),%r9
jmp    1250 <inet_ntoa+0x150>
mov    %esi,%r8d
and    $0xffffffe0,%r8d
sub    %r8,%rdi
lea    0x2e9e(%rip),%rcx
lea    (%r8,%rcx,1),%r9
add    $0x1,%r9
movzbl %al,%r11d
lea    (%rsp,%r11,1),%r14
add    $0xffffffffffffffed,%r14
and    $0xffffffe0,%r11d
neg    %r11
lea    0x2e8d(%rip),%rbx
xor    %eax,%eax
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%r14,%rax,1),%xmm1
movdqu (%r14,%rax,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rbx)
movdqu %xmm1,(%rbx)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rax
cmp    %rax,%r11
jne    11c0 <inet_ntoa+0xc0>
cmp    %rsi,%r8
je     1262 <inet_ntoa+0x162>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x3(%rsp,%rdi,1),%eax
mov    %al,(%r9)
add    $0x1,%r9
add    $0xffffffffffffffff,%rdi
jb     1250 <inet_ntoa+0x150>
movb   $0x2e,(%r9)
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movzbl %dl,%ecx
imul   $0xcd,%ecx,%edx
shr    $0xb,%edx
lea    (%rdx,%rdx,1),%esi
lea    (%rsi,%rsi,4),%esi
mov    %ecx,%ebx
sub    %sil,%bl
or     $0x30,%bl
movzbl %al,%edi
add    $0x1,%al
mov    %bl,-0x3(%rsp,%rdi,1)
cmp    $0x9,%cl
ja     1270 <inet_ntoa+0x170>
mov    %eax,%esi
sub    $0x1,%sil
jae    12ac <inet_ntoa+0x1ac>
add    $0x1,%r9
mov    %r9,%rdx
jmp    142d <inet_ntoa+0x32d>
lea    0x2(%r9),%rdx
mov    %bl,0x1(%r9)
cmp    $0x1,%al
je     142d <inet_ntoa+0x32d>
lea    -0x1(%rdi),%r8
cmp    $0x20,%sil
jb     13a8 <inet_ntoa+0x2a8>
lea    (%rsp,%rdi,1),%rax
add    $0xfffffffffffffffd,%rax
cmp    %rax,%rdx
jae    12ed <inet_ntoa+0x1ed>
lea    (%rdi,%r9,1),%rax
add    $0x2,%rax
lea    -0x3(%rsp),%rcx
cmp    %rax,%rcx
jb     13a8 <inet_ntoa+0x2a8>
mov    %edi,%r11d
and    $0xffffffe0,%r11d
sub    %r11,%r8
add    %r11,%rdx
add    $0x12,%r9
movzbl %sil,%esi
lea    (%rsp,%rsi,1),%rax
add    $0xffffffffffffffed,%rax
and    $0xffffffe0,%esi
neg    %rsi
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rax,%rbx,1),%xmm1
movdqu (%rax,%rbx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%r9)
movdqu %xmm1,(%r9)
add    $0x20,%r9
add    $0xffffffffffffffe0,%rbx
cmp    %rbx,%rsi
jne    1320 <inet_ntoa+0x220>
cmp    %rdi,%r11
je     142d <inet_ntoa+0x32d>
lea    0x1(%r8),%eax
mov    %r8,%rsi
and    $0x7,%rax
je     13d5 <inet_ntoa+0x2d5>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rsp,%rsi,1),%ecx
mov    %cl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
add    $0xffffffffffffffff,%rax
jne    13c0 <inet_ntoa+0x2c0>
cmp    $0x7,%r8
jb     142d <inet_ntoa+0x32d>
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rsp,%rsi,1),%eax
mov    %al,(%rdx)
movzbl -0x4(%rsp,%rsi,1),%eax
mov    %al,0x1(%rdx)
movzbl -0x5(%rsp,%rsi,1),%eax
mov    %al,0x2(%rdx)
movzbl -0x6(%rsp,%rsi,1),%eax
mov    %al,0x3(%rdx)
movzbl -0x7(%rsp,%rsi,1),%eax
mov    %al,0x4(%rdx)
movzbl -0x8(%rsp,%rsi,1),%eax
mov    %al,0x5(%rdx)
movzbl -0x9(%rsp,%rsi,1),%eax
mov    %al,0x6(%rdx)
movzbl -0xa(%rsp,%rsi,1),%eax
mov    %al,0x7(%rdx)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    $0xffffffffffffffff,%rsi
jne    13e0 <inet_ntoa+0x2e0>
movb   $0x2e,(%rdx)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl %r15b,%ecx
imul   $0xcd,%ecx,%r15d
shr    $0xb,%r15d
lea    (%r15,%r15,1),%esi
lea    (%rsi,%rsi,4),%esi
mov    %ecx,%ebx
sub    %sil,%bl
or     $0x30,%bl
movzbl %al,%edi
add    $0x1,%al
mov    %bl,-0x3(%rsp,%rdi,1)
cmp    $0x9,%cl
ja     1440 <inet_ntoa+0x340>
mov    %eax,%esi
sub    $0x1,%sil
jae    1480 <inet_ntoa+0x380>
add    $0x1,%rdx
mov    %rdx,%rcx
jmp    15ed <inet_ntoa+0x4ed>
lea    0x2(%rdx),%rcx
mov    %bl,0x1(%rdx)
cmp    $0x1,%al
je     15ed <inet_ntoa+0x4ed>
lea    -0x1(%rdi),%r9
cmp    $0x20,%sil
jb     1572 <inet_ntoa+0x472>
lea    (%rsp,%rdi,1),%rax
add    $0xfffffffffffffffd,%rax
cmp    %rax,%rcx
jae    14c0 <inet_ntoa+0x3c0>
lea    (%rdi,%rdx,1),%rax
add    $0x2,%rax
lea    -0x3(%rsp),%rbx
cmp    %rax,%rbx
jb     1572 <inet_ntoa+0x472>
mov    %edi,%r8d
and    $0xffffffe0,%r8d
sub    %r8,%r9
add    %r8,%rcx
add    $0x12,%rdx
movzbl %sil,%esi
lea    (%rsp,%rsi,1),%rax
add    $0xffffffffffffffed,%rax
and    $0xffffffe0,%esi
neg    %rsi
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movdqu -0x10(%rax,%rbx,1),%xmm1
movdqu (%rax,%rbx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rdx)
movdqu %xmm1,(%rdx)
add    $0x20,%rdx
add    $0xffffffffffffffe0,%rbx
cmp    %rbx,%rsi
jne    14f0 <inet_ntoa+0x3f0>
cmp    %rdi,%r8
je     15ed <inet_ntoa+0x4ed>
lea    0x1(%r9),%eax
mov    %r9,%rdx
and    $0x7,%rax
je     1595 <inet_ntoa+0x495>
nop
movzbl -0x3(%rsp,%rdx,1),%ebx
mov    %bl,(%rcx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rax
jne    1580 <inet_ntoa+0x480>
cmp    $0x7,%r9
jb     15ed <inet_ntoa+0x4ed>
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rsp,%rdx,1),%eax
mov    %al,(%rcx)
movzbl -0x4(%rsp,%rdx,1),%eax
mov    %al,0x1(%rcx)
movzbl -0x5(%rsp,%rdx,1),%eax
mov    %al,0x2(%rcx)
movzbl -0x6(%rsp,%rdx,1),%eax
mov    %al,0x3(%rcx)
movzbl -0x7(%rsp,%rdx,1),%eax
mov    %al,0x4(%rcx)
movzbl -0x8(%rsp,%rdx,1),%eax
mov    %al,0x5(%rcx)
movzbl -0x9(%rsp,%rdx,1),%eax
mov    %al,0x6(%rcx)
movzbl -0xa(%rsp,%rdx,1),%eax
mov    %al,0x7(%rcx)
add    $0x8,%rcx
add    $0xfffffffffffffff8,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    15a0 <inet_ntoa+0x4a0>
movb   $0x2e,(%rcx)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl %r10b,%eax
imul   $0xcd,%eax,%r10d
shr    $0xb,%r10d
lea    (%r10,%r10,1),%esi
lea    (%rsi,%rsi,4),%esi
mov    %eax,%ebx
sub    %sil,%bl
or     $0x30,%bl
movzbl %dl,%esi
add    $0x1,%dl
mov    %bl,-0x3(%rsp,%rsi,1)
cmp    $0x9,%al
ja     1600 <inet_ntoa+0x500>
mov    %edx,%edi
sub    $0x1,%dil
jae    1640 <inet_ntoa+0x540>
add    $0x1,%rcx
mov    %rcx,%rax
jmp    17ad <inet_ntoa+0x6ad>
lea    0x2(%rcx),%rax
mov    %bl,0x1(%rcx)
cmp    $0x1,%dl
je     17ad <inet_ntoa+0x6ad>
lea    -0x1(%rsi),%r9
cmp    $0x20,%dil
jb     1732 <inet_ntoa+0x632>
lea    (%rsp,%rsi,1),%rdx
add    $0xfffffffffffffffd,%rdx
cmp    %rdx,%rax
jae    1681 <inet_ntoa+0x581>
lea    (%rsi,%rcx,1),%rdx
add    $0x2,%rdx
lea    -0x3(%rsp),%rbx
cmp    %rdx,%rbx
jb     1732 <inet_ntoa+0x632>
mov    %esi,%r8d
and    $0xffffffe0,%r8d
sub    %r8,%r9
add    %r8,%rax
add    $0x12,%rcx
movzbl %dil,%edx
lea    (%rsp,%rdx,1),%rdi
add    $0xffffffffffffffed,%rdi
and    $0xffffffe0,%edx
neg    %rdx
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rbx,1),%xmm1
movdqu (%rdi,%rbx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rcx)
movdqu %xmm1,(%rcx)
add    $0x20,%rcx
add    $0xffffffffffffffe0,%rbx
cmp    %rbx,%rdx
jne    16b0 <inet_ntoa+0x5b0>
cmp    %rsi,%r8
je     17ad <inet_ntoa+0x6ad>
lea    0x1(%r9),%edx
mov    %r9,%rcx
and    $0x7,%rdx
je     1755 <inet_ntoa+0x655>
nop
movzbl -0x3(%rsp,%rcx,1),%ebx
mov    %bl,(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rdx
jne    1740 <inet_ntoa+0x640>
cmp    $0x7,%r9
jb     17ad <inet_ntoa+0x6ad>
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rsp,%rcx,1),%edx
mov    %dl,(%rax)
movzbl -0x4(%rsp,%rcx,1),%edx
mov    %dl,0x1(%rax)
movzbl -0x5(%rsp,%rcx,1),%edx
mov    %dl,0x2(%rax)
movzbl -0x6(%rsp,%rcx,1),%edx
mov    %dl,0x3(%rax)
movzbl -0x7(%rsp,%rcx,1),%edx
mov    %dl,0x4(%rax)
movzbl -0x8(%rsp,%rcx,1),%edx
mov    %dl,0x5(%rax)
movzbl -0x9(%rsp,%rcx,1),%edx
mov    %dl,0x6(%rax)
movzbl -0xa(%rsp,%rcx,1),%edx
mov    %dl,0x7(%rax)
add    $0x8,%rax
add    $0xfffffffffffffff8,%rcx
cmp    $0xffffffffffffffff,%rcx
jne    1760 <inet_ntoa+0x660>
movb   $0x0,(%rax)
lea    0x2879(%rip),%rax
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@inet_ntoa.str = internal global [16 x i8] zeroinitializer
define i8* @inet_ntoa(i64 %0) {
%2 = alloca i64
%3 = alloca [3 x i8]
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8
%7 = alloca i8
%8 = alloca i8
store i64 %0, i64* %2
store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 0), i8** %4
%9 = bitcast i64* %2 to i8*
store i8* %9, i8** %5
store i8 0, i8* %7
br label %10
10: ; preds = %55, %1
%11 = load i8, i8* %7
%12 = zext i8 %11 to i32
%13 = icmp slt i32 %12, 4
br i1 %13, label %14, label %58
14: ; preds = %10
store i8 0, i8* %8
br label %15
15: ; preds = %34, %14
%16 = load i8*, i8** %5
%17 = load i8, i8* %16
%18 = zext i8 %17 to i32
%19 = srem i32 %18, 10
%20 = trunc i32 %19 to i8
store i8 %20, i8* %6
%21 = load i8*, i8** %5
%22 = load i8, i8* %21
%23 = zext i8 %22 to i32
%24 = sdiv i32 %23, 10
%25 = trunc i32 %24 to i8
store i8 %25, i8* %21
%26 = load i8, i8* %6
%27 = zext i8 %26 to i32
%28 = add nsw i32 48, %27
%29 = trunc i32 %28 to i8
%30 = load i8, i8* %8
%31 = add i8 %30, 1
store i8 %31, i8* %8
%32 = zext i8 %30 to i64
%33 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 %32
store i8 %29, i8* %33
br label %34
34: ; preds = %15
%35 = load i8*, i8** %5
%36 = load i8, i8* %35
%37 = icmp ne i8 %36, 0
br i1 %37, label %15, label %38
38: ; preds = %34
br label %39
39: ; preds = %43, %38
%40 = load i8, i8* %8
%41 = add i8 %40, -1
store i8 %41, i8* %8
%42 = icmp ne i8 %40, 0
br i1 %42, label %43, label %50
43: ; preds = %39
%44 = load i8, i8* %8
%45 = zext i8 %44 to i64
%46 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 %45
%47 = load i8, i8* %46
%48 = load i8*, i8** %4
%49 = getelementptr inbounds i8, i8* %48, i32 1
store i8* %49, i8** %4
store i8 %47, i8* %48
br label %39
50: ; preds = %39
%51 = load i8*, i8** %4
%52 = getelementptr inbounds i8, i8* %51, i32 1
store i8* %52, i8** %4
store i8 46, i8* %51
%53 = load i8*, i8** %5
%54 = getelementptr inbounds i8, i8* %53, i32 1
store i8* %54, i8** %5
br label %55
55: ; preds = %50
%56 = load i8, i8* %7
%57 = add i8 %56, 1
store i8 %57, i8* %7
br label %10
58: ; preds = %10
%59 = load i8*, i8** %4
%60 = getelementptr inbounds i8, i8* %59, i32 -1
store i8* %60, i8** %4
store i8 0, i8* %60
ret i8* getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 0)
}

LLVM IR (-O2):
@inet_ntoa.str = internal global [16 x i8] zeroinitializer
define i8* @inet_ntoa(i64 %0) {
%2 = alloca [3 x i8]
%3 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 0
%4 = trunc i64 %0 to i8
%5 = lshr i64 %0, 8
%6 = trunc i64 %5 to i8
%7 = lshr i64 %0, 16
%8 = trunc i64 %7 to i8
%9 = lshr i64 %0, 24
%10 = trunc i64 %9 to i8
%11 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 0
br label %12
12: ; preds = %1, %12
%13 = phi i8 [ %16, %12 ], [ %4, %1 ]
%14 = phi i8 [ %18, %12 ], [ 0, %1 ]
%15 = urem i8 %13, 10
%16 = udiv i8 %13, 10
%17 = or i8 %15, 48
%18 = add i8 %14, 1
%19 = zext i8 %14 to i64
%20 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %19
store i8 %17, i8* %20
%21 = icmp ult i8 %13, 10
br i1 %21, label %22, label %12
22: ; preds = %12
%23 = icmp eq i8 %18, 0
br i1 %23, label %64, label %24
24: ; preds = %22
store i8 %17, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 0)
%25 = add nsw i64 %19, -1
%26 = icmp eq i8 %14, 0
br i1 %26, label %64, label %27
27: ; preds = %24
%28 = icmp ult i8 %14, 32
br i1 %28, label %53, label %29
29: ; preds = %27
%30 = and i64 %19, 224
%31 = sub nsw i64 %25, %30
%32 = getelementptr i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 1), i64 %30
br label %33
33: ; preds = %33, %29
%34 = phi i64 [ 0, %29 ], [ %49, %33 ]
%35 = sub i64 %25, %34
%36 = getelementptr i8, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 1), i64 %34
%37 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %35
%38 = getelementptr inbounds i8, i8* %37, i64 -15
%39 = bitcast i8* %38 to <16 x i8>*
%40 = load <16 x i8>, <16 x i8>* %39
%41 = shufflevector <16 x i8> %40, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%42 = getelementptr inbounds i8, i8* %37, i64 -31
%43 = bitcast i8* %42 to <16 x i8>*
%44 = load <16 x i8>, <16 x i8>* %43
%45 = shufflevector <16 x i8> %44, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%46 = bitcast i8* %36 to <16 x i8>*
store <16 x i8> %41, <16 x i8>* %46
%47 = getelementptr i8, i8* %36, i64 16
%48 = bitcast i8* %47 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %48
%49 = add nuw i64 %34, 32
%50 = icmp eq i64 %49, %30
br i1 %50, label %51, label %33
51: ; preds = %33
%52 = icmp eq i64 %30, %19
br i1 %52, label %64, label %53
53: ; preds = %27, %51
%54 = phi i64 [ %25, %27 ], [ %31, %51 ]
%55 = phi i8* [ getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 1), %27 ], [ %32, %51 ]
br label %56
56: ; preds = %53, %56
%57 = phi i64 [ %62, %56 ], [ %54, %53 ]
%58 = phi i8* [ %61, %56 ], [ %55, %53 ]
%59 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %57
%60 = load i8, i8* %59
%61 = getelementptr inbounds i8, i8* %58, i64 1
store i8 %60, i8* %58
%62 = add nsw i64 %57, -1
%63 = icmp eq i64 %57, 0
br i1 %63, label %64, label %56
64: ; preds = %56, %24, %51, %22
%65 = phi i8* [ getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 0), %22 ], [ getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 1), %24 ], [ %32, %51 ], [ %61, %56 ]
store i8 46, i8* %65
br label %66
66: ; preds = %66, %64
%67 = phi i8 [ %70, %66 ], [ %6, %64 ]
%68 = phi i8 [ %72, %66 ], [ 0, %64 ]
%69 = urem i8 %67, 10
%70 = udiv i8 %67, 10
%71 = or i8 %69, 48
%72 = add i8 %68, 1
%73 = zext i8 %68 to i64
%74 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %73
store i8 %71, i8* %74
%75 = icmp ult i8 %67, 10
br i1 %75, label %76, label %66
76: ; preds = %66
%77 = getelementptr inbounds i8, i8* %65, i64 1
%78 = icmp eq i8 %72, 0
br i1 %78, label %173, label %79
79: ; preds = %76
%80 = getelementptr i8, i8* %65, i64 2
store i8 %71, i8* %77
%81 = add nsw i64 %73, -1
%82 = icmp eq i8 %68, 0
br i1 %82, label %173, label %83
83: ; preds = %79
%84 = icmp ult i8 %68, 32
br i1 %84, label %116, label %85
85: ; preds = %83
%86 = add nuw nsw i64 %73, 2
%87 = getelementptr i8, i8* %65, i64 %86
%88 = getelementptr [3 x i8], [3 x i8]* %2, i64 0, i64 %73
%89 = icmp ult i8* %80, %88
%90 = icmp ult i8* %3, %87
%91 = and i1 %89, %90
br i1 %91, label %116, label %92
92: ; preds = %85
%93 = and i64 %73, 224
%94 = sub nsw i64 %81, %93
%95 = getelementptr i8, i8* %80, i64 %93
br label %96
96: ; preds = %96, %92
%97 = phi i64 [ 0, %92 ], [ %112, %96 ]
%98 = sub i64 %81, %97
%99 = getelementptr i8, i8* %80, i64 %97
%100 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %98
%101 = getelementptr inbounds i8, i8* %100, i64 -15
%102 = bitcast i8* %101 to <16 x i8>*
%103 = load <16 x i8>, <16 x i8>* %102
%104 = shufflevector <16 x i8> %103, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%105 = getelementptr inbounds i8, i8* %100, i64 -31
%106 = bitcast i8* %105 to <16 x i8>*
%107 = load <16 x i8>, <16 x i8>* %106
%108 = shufflevector <16 x i8> %107, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%109 = bitcast i8* %99 to <16 x i8>*
store <16 x i8> %104, <16 x i8>* %109
%110 = getelementptr i8, i8* %99, i64 16
%111 = bitcast i8* %110 to <16 x i8>*
store <16 x i8> %108, <16 x i8>* %111
%112 = add nuw i64 %97, 32
%113 = icmp eq i64 %112, %93
br i1 %113, label %114, label %96
114: ; preds = %96
%115 = icmp eq i64 %93, %73
br i1 %115, label %173, label %116
116: ; preds = %85, %83, %114
%117 = phi i64 [ %81, %85 ], [ %81, %83 ], [ %94, %114 ]
%118 = phi i8* [ %80, %85 ], [ %80, %83 ], [ %95, %114 ]
%119 = add nsw i64 %117, 1
%120 = and i64 %119, 7
%121 = icmp eq i64 %120, 0
br i1 %121, label %132, label %122
122: ; preds = %116, %122
%123 = phi i64 [ %129, %122 ], [ %117, %116 ]
%124 = phi i8* [ %128, %122 ], [ %118, %116 ]
%125 = phi i64 [ %130, %122 ], [ 0, %116 ]
%126 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %123
%127 = load i8, i8* %126
%128 = getelementptr inbounds i8, i8* %124, i64 1
store i8 %127, i8* %124
%129 = add nsw i64 %123, -1
%130 = add i64 %125, 1
%131 = icmp eq i64 %130, %120
br i1 %131, label %132, label %122
132: ; preds = %122, %116
%133 = phi i8* [ undef, %116 ], [ %128, %122 ]
%134 = phi i64 [ %117, %116 ], [ %129, %122 ]
%135 = phi i8* [ %118, %116 ], [ %128, %122 ]
%136 = icmp ult i64 %117, 7
br i1 %136, label %173, label %137
137: ; preds = %132, %137
%138 = phi i64 [ %171, %137 ], [ %134, %132 ]
%139 = phi i8* [ %170, %137 ], [ %135, %132 ]
%140 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %138
%141 = load i8, i8* %140
%142 = getelementptr inbounds i8, i8* %139, i64 1
store i8 %141, i8* %139
%143 = add nsw i64 %138, -1
%144 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %143
%145 = load i8, i8* %144
%146 = getelementptr inbounds i8, i8* %139, i64 2
store i8 %145, i8* %142
%147 = add nsw i64 %138, -2
%148 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %147
%149 = load i8, i8* %148
%150 = getelementptr inbounds i8, i8* %139, i64 3
store i8 %149, i8* %146
%151 = add nsw i64 %138, -3
%152 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %151
%153 = load i8, i8* %152
%154 = getelementptr inbounds i8, i8* %139, i64 4
store i8 %153, i8* %150
%155 = add nsw i64 %138, -4
%156 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %155
%157 = load i8, i8* %156
%158 = getelementptr inbounds i8, i8* %139, i64 5
store i8 %157, i8* %154
%159 = add nsw i64 %138, -5
%160 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %159
%161 = load i8, i8* %160
%162 = getelementptr inbounds i8, i8* %139, i64 6
store i8 %161, i8* %158
%163 = add nsw i64 %138, -6
%164 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %163
%165 = load i8, i8* %164
%166 = getelementptr inbounds i8, i8* %139, i64 7
store i8 %165, i8* %162
%167 = add nsw i64 %138, -7
%168 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %167
%169 = load i8, i8* %168
%170 = getelementptr inbounds i8, i8* %139, i64 8
store i8 %169, i8* %166
%171 = add nsw i64 %138, -8
%172 = icmp eq i64 %167, 0
br i1 %172, label %173, label %137
173: ; preds = %132, %137, %79, %114, %76
%174 = phi i8* [ %77, %76 ], [ %80, %79 ], [ %95, %114 ], [ %133, %132 ], [ %170, %137 ]
store i8 46, i8* %174
br label %175
175: ; preds = %175, %173
%176 = phi i8 [ %179, %175 ], [ %8, %173 ]
%177 = phi i8 [ %181, %175 ], [ 0, %173 ]
%178 = urem i8 %176, 10
%179 = udiv i8 %176, 10
%180 = or i8 %178, 48
%181 = add i8 %177, 1
%182 = zext i8 %177 to i64
%183 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %182
store i8 %180, i8* %183
%184 = icmp ult i8 %176, 10
br i1 %184, label %185, label %175
185: ; preds = %175
%186 = getelementptr inbounds i8, i8* %174, i64 1
%187 = icmp eq i8 %181, 0
br i1 %187, label %282, label %188
188: ; preds = %185
%189 = getelementptr i8, i8* %174, i64 2
store i8 %180, i8* %186
%190 = add nsw i64 %182, -1
%191 = icmp eq i8 %177, 0
br i1 %191, label %282, label %192
192: ; preds = %188
%193 = icmp ult i8 %177, 32
br i1 %193, label %225, label %194
194: ; preds = %192
%195 = add nuw nsw i64 %182, 2
%196 = getelementptr i8, i8* %174, i64 %195
%197 = getelementptr [3 x i8], [3 x i8]* %2, i64 0, i64 %182
%198 = icmp ult i8* %189, %197
%199 = icmp ult i8* %3, %196
%200 = and i1 %198, %199
br i1 %200, label %225, label %201
201: ; preds = %194
%202 = and i64 %182, 224
%203 = sub nsw i64 %190, %202
%204 = getelementptr i8, i8* %189, i64 %202
br label %205
205: ; preds = %205, %201
%206 = phi i64 [ 0, %201 ], [ %221, %205 ]
%207 = sub i64 %190, %206
%208 = getelementptr i8, i8* %189, i64 %206
%209 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %207
%210 = getelementptr inbounds i8, i8* %209, i64 -15
%211 = bitcast i8* %210 to <16 x i8>*
%212 = load <16 x i8>, <16 x i8>* %211
%213 = shufflevector <16 x i8> %212, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%214 = getelementptr inbounds i8, i8* %209, i64 -31
%215 = bitcast i8* %214 to <16 x i8>*
%216 = load <16 x i8>, <16 x i8>* %215
%217 = shufflevector <16 x i8> %216, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%218 = bitcast i8* %208 to <16 x i8>*
store <16 x i8> %213, <16 x i8>* %218
%219 = getelementptr i8, i8* %208, i64 16
%220 = bitcast i8* %219 to <16 x i8>*
store <16 x i8> %217, <16 x i8>* %220
%221 = add nuw i64 %206, 32
%222 = icmp eq i64 %221, %202
br i1 %222, label %223, label %205
223: ; preds = %205
%224 = icmp eq i64 %202, %182
br i1 %224, label %282, label %225
225: ; preds = %194, %192, %223
%226 = phi i64 [ %190, %194 ], [ %190, %192 ], [ %203, %223 ]
%227 = phi i8* [ %189, %194 ], [ %189, %192 ], [ %204, %223 ]
%228 = add nsw i64 %226, 1
%229 = and i64 %228, 7
%230 = icmp eq i64 %229, 0
br i1 %230, label %241, label %231
231: ; preds = %225, %231
%232 = phi i64 [ %238, %231 ], [ %226, %225 ]
%233 = phi i8* [ %237, %231 ], [ %227, %225 ]
%234 = phi i64 [ %239, %231 ], [ 0, %225 ]
%235 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %232
%236 = load i8, i8* %235
%237 = getelementptr inbounds i8, i8* %233, i64 1
store i8 %236, i8* %233
%238 = add nsw i64 %232, -1
%239 = add i64 %234, 1
%240 = icmp eq i64 %239, %229
br i1 %240, label %241, label %231
241: ; preds = %231, %225
%242 = phi i8* [ undef, %225 ], [ %237, %231 ]
%243 = phi i64 [ %226, %225 ], [ %238, %231 ]
%244 = phi i8* [ %227, %225 ], [ %237, %231 ]
%245 = icmp ult i64 %226, 7
br i1 %245, label %282, label %246
246: ; preds = %241, %246
%247 = phi i64 [ %280, %246 ], [ %243, %241 ]
%248 = phi i8* [ %279, %246 ], [ %244, %241 ]
%249 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %247
%250 = load i8, i8* %249
%251 = getelementptr inbounds i8, i8* %248, i64 1
store i8 %250, i8* %248
%252 = add nsw i64 %247, -1
%253 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %252
%254 = load i8, i8* %253
%255 = getelementptr inbounds i8, i8* %248, i64 2
store i8 %254, i8* %251
%256 = add nsw i64 %247, -2
%257 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %256
%258 = load i8, i8* %257
%259 = getelementptr inbounds i8, i8* %248, i64 3
store i8 %258, i8* %255
%260 = add nsw i64 %247, -3
%261 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %260
%262 = load i8, i8* %261
%263 = getelementptr inbounds i8, i8* %248, i64 4
store i8 %262, i8* %259
%264 = add nsw i64 %247, -4
%265 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %264
%266 = load i8, i8* %265
%267 = getelementptr inbounds i8, i8* %248, i64 5
store i8 %266, i8* %263
%268 = add nsw i64 %247, -5
%269 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %268
%270 = load i8, i8* %269
%271 = getelementptr inbounds i8, i8* %248, i64 6
store i8 %270, i8* %267
%272 = add nsw i64 %247, -6
%273 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %272
%274 = load i8, i8* %273
%275 = getelementptr inbounds i8, i8* %248, i64 7
store i8 %274, i8* %271
%276 = add nsw i64 %247, -7
%277 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %276
%278 = load i8, i8* %277
%279 = getelementptr inbounds i8, i8* %248, i64 8
store i8 %278, i8* %275
%280 = add nsw i64 %247, -8
%281 = icmp eq i64 %276, 0
br i1 %281, label %282, label %246
282: ; preds = %241, %246, %188, %223, %185
%283 = phi i8* [ %186, %185 ], [ %189, %188 ], [ %204, %223 ], [ %242, %241 ], [ %279, %246 ]
store i8 46, i8* %283
br label %284
284: ; preds = %284, %282
%285 = phi i8 [ %288, %284 ], [ %10, %282 ]
%286 = phi i8 [ %290, %284 ], [ 0, %282 ]
%287 = urem i8 %285, 10
%288 = udiv i8 %285, 10
%289 = or i8 %287, 48
%290 = add i8 %286, 1
%291 = zext i8 %286 to i64
%292 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %291
store i8 %289, i8* %292
%293 = icmp ult i8 %285, 10
br i1 %293, label %294, label %284
294: ; preds = %284
%295 = getelementptr inbounds i8, i8* %283, i64 1
%296 = icmp eq i8 %290, 0
br i1 %296, label %391, label %297
297: ; preds = %294
%298 = getelementptr i8, i8* %283, i64 2
store i8 %289, i8* %295
%299 = add nsw i64 %291, -1
%300 = icmp eq i8 %286, 0
br i1 %300, label %391, label %301
301: ; preds = %297
%302 = icmp ult i8 %286, 32
br i1 %302, label %334, label %303
303: ; preds = %301
%304 = add nuw nsw i64 %291, 2
%305 = getelementptr i8, i8* %283, i64 %304
%306 = getelementptr [3 x i8], [3 x i8]* %2, i64 0, i64 %291
%307 = icmp ult i8* %298, %306
%308 = icmp ult i8* %3, %305
%309 = and i1 %307, %308
br i1 %309, label %334, label %310
310: ; preds = %303
%311 = and i64 %291, 224
%312 = sub nsw i64 %299, %311
%313 = getelementptr i8, i8* %298, i64 %311
br label %314
314: ; preds = %314, %310
%315 = phi i64 [ 0, %310 ], [ %330, %314 ]
%316 = sub i64 %299, %315
%317 = getelementptr i8, i8* %298, i64 %315
%318 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %316
%319 = getelementptr inbounds i8, i8* %318, i64 -15
%320 = bitcast i8* %319 to <16 x i8>*
%321 = load <16 x i8>, <16 x i8>* %320
%322 = shufflevector <16 x i8> %321, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%323 = getelementptr inbounds i8, i8* %318, i64 -31
%324 = bitcast i8* %323 to <16 x i8>*
%325 = load <16 x i8>, <16 x i8>* %324
%326 = shufflevector <16 x i8> %325, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%327 = bitcast i8* %317 to <16 x i8>*
store <16 x i8> %322, <16 x i8>* %327
%328 = getelementptr i8, i8* %317, i64 16
%329 = bitcast i8* %328 to <16 x i8>*
store <16 x i8> %326, <16 x i8>* %329
%330 = add nuw i64 %315, 32
%331 = icmp eq i64 %330, %311
br i1 %331, label %332, label %314
332: ; preds = %314
%333 = icmp eq i64 %311, %291
br i1 %333, label %391, label %334
334: ; preds = %303, %301, %332
%335 = phi i64 [ %299, %303 ], [ %299, %301 ], [ %312, %332 ]
%336 = phi i8* [ %298, %303 ], [ %298, %301 ], [ %313, %332 ]
%337 = add nsw i64 %335, 1
%338 = and i64 %337, 7
%339 = icmp eq i64 %338, 0
br i1 %339, label %350, label %340
340: ; preds = %334, %340
%341 = phi i64 [ %347, %340 ], [ %335, %334 ]
%342 = phi i8* [ %346, %340 ], [ %336, %334 ]
%343 = phi i64 [ %348, %340 ], [ 0, %334 ]
%344 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %341
%345 = load i8, i8* %344
%346 = getelementptr inbounds i8, i8* %342, i64 1
store i8 %345, i8* %342
%347 = add nsw i64 %341, -1
%348 = add i64 %343, 1
%349 = icmp eq i64 %348, %338
br i1 %349, label %350, label %340
350: ; preds = %340, %334
%351 = phi i8* [ undef, %334 ], [ %346, %340 ]
%352 = phi i64 [ %335, %334 ], [ %347, %340 ]
%353 = phi i8* [ %336, %334 ], [ %346, %340 ]
%354 = icmp ult i64 %335, 7
br i1 %354, label %391, label %355
355: ; preds = %350, %355
%356 = phi i64 [ %389, %355 ], [ %352, %350 ]
%357 = phi i8* [ %388, %355 ], [ %353, %350 ]
%358 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %356
%359 = load i8, i8* %358
%360 = getelementptr inbounds i8, i8* %357, i64 1
store i8 %359, i8* %357
%361 = add nsw i64 %356, -1
%362 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %361
%363 = load i8, i8* %362
%364 = getelementptr inbounds i8, i8* %357, i64 2
store i8 %363, i8* %360
%365 = add nsw i64 %356, -2
%366 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %365
%367 = load i8, i8* %366
%368 = getelementptr inbounds i8, i8* %357, i64 3
store i8 %367, i8* %364
%369 = add nsw i64 %356, -3
%370 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %369
%371 = load i8, i8* %370
%372 = getelementptr inbounds i8, i8* %357, i64 4
store i8 %371, i8* %368
%373 = add nsw i64 %356, -4
%374 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %373
%375 = load i8, i8* %374
%376 = getelementptr inbounds i8, i8* %357, i64 5
store i8 %375, i8* %372
%377 = add nsw i64 %356, -5
%378 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %377
%379 = load i8, i8* %378
%380 = getelementptr inbounds i8, i8* %357, i64 6
store i8 %379, i8* %376
%381 = add nsw i64 %356, -6
%382 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %381
%383 = load i8, i8* %382
%384 = getelementptr inbounds i8, i8* %357, i64 7
store i8 %383, i8* %380
%385 = add nsw i64 %356, -7
%386 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 %385
%387 = load i8, i8* %386
%388 = getelementptr inbounds i8, i8* %357, i64 8
store i8 %387, i8* %384
%389 = add nsw i64 %356, -8
%390 = icmp eq i64 %385, 0
br i1 %390, label %391, label %355
391: ; preds = %350, %355, %297, %332, %294
%392 = phi i8* [ %295, %294 ], [ %298, %297 ], [ %313, %332 ], [ %351, %350 ], [ %388, %355 ]
store i8 0, i8* %392
ret i8* getelementptr inbounds ([16 x i8], [16 x i8]* @inet_ntoa.str, i64 0, i64 0)
}