#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 */
typedef int /*<<< orphan*/ uint32_t;
typedef int /*<<< orphan*/ uint16_t;

/* Variables and functions */
void *atoi(char *);
unsigned long atol(char *);
int /*<<< orphan*/ htonl(unsigned long);
int /*<<< orphan*/ htons(void *);
char *strchr(char *, char);
void raop_prepare_alac(unsigned char *header, char *format,
                       unsigned long *samplerate, unsigned char *channels,
                       unsigned long *samples) {
  char *fmt[12];
  char *f, *f2;
  int i;
  f = format;
  for (i = 0; i < 12; i++) {
    f2 = strchr(f, ' ');
    if (f2 == NULL) {
      fmt[i] = f;
      break;
    }
    *f2 = '\0';
    fmt[i] = f;
    f = f2 + 1;
  }
  header += 24;
  *((uint32_t *)header) = htonl(atol(fmt[1]));
  if (samples != NULL)
    *samples = atol(fmt[1]);
  header += 4;
  *header++ = atoi(fmt[2]);
  *header++ = atoi(fmt[3]);
  *header++ = atoi(fmt[4]);
  *header++ = atoi(fmt[5]);
  *header++ = atoi(fmt[6]);
  *header++ = atoi(fmt[7]);
  if (channels != NULL)
    *channels = atoi(fmt[7]);
  *((uint16_t *)header) = htons(atoi(fmt[8]));
  header += 2;
  *((uint32_t *)header) = htonl(atol(fmt[9]));
  header += 4;
  *((uint32_t *)header) = htonl(atol(fmt[10]));
  header += 4;
  *((uint32_t *)header) = htonl(atol(fmt[11]));
  if (samplerate != NULL)
    *samplerate = atol(fmt[11]);
}


x86 assembly (clang, -O0):
<raop_prepare_alac>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0xa4(%rbp)
cmpl   $0xc,-0xa4(%rbp)
jge    1218 <raop_prepare_alac+0xc8>
mov    -0x98(%rbp),%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
mov    %rax,-0xa0(%rbp)
cmpq   $0x0,-0xa0(%rbp)
jne    11d2 <raop_prepare_alac+0x82>
mov    -0x98(%rbp),%rcx
movslq -0xa4(%rbp),%rax
mov    %rcx,-0x90(%rbp,%rax,8)
ff
jmp    1218 <raop_prepare_alac+0xc8>
mov    -0xa0(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x98(%rbp),%rcx
movslq -0xa4(%rbp),%rax
mov    %rcx,-0x90(%rbp,%rax,8)
ff
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1184 <raop_prepare_alac+0x34>
mov    -0x8(%rbp),%rax
add    $0x18,%rax
mov    %rax,-0x8(%rbp)
mov    -0x88(%rbp),%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
cmpq   $0x0,-0x28(%rbp)
je     1261 <raop_prepare_alac+0x111>
mov    -0x88(%rbp),%rdi
call   1060 <atol@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x80(%rbp),%rdi
call   1070 <atoi@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x78(%rbp),%rdi
call   1070 <atoi@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x70(%rbp),%rdi
call   1070 <atoi@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rdi
call   1070 <atoi@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x60(%rbp),%rdi
call   1070 <atoi@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rdi
call   1070 <atoi@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
cmpq   $0x0,-0x20(%rbp)
je     1331 <raop_prepare_alac+0x1e1>
mov    -0x58(%rbp),%rdi
call   1070 <atoi@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x50(%rbp),%rdi
call   1070 <atoi@plt>
mov    %rax,%rdi
call   1030 <htons@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x8(%rbp)
mov    -0x48(%rbp),%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x40(%rbp),%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x38(%rbp),%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
cmpq   $0x0,-0x18(%rbp)
je     13d7 <raop_prepare_alac+0x287>
mov    -0x38(%rbp),%rdi
call   1060 <atol@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<raop_prepare_alac>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8,%r12
mov    %rcx,%r15
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r13
mov    %rsi,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     131f <raop_prepare_alac+0x1cf>
mov    %rax,%rbp
movb   $0x0,(%rax)
mov    %rbx,(%rsp)
add    $0x1,%rbp
mov    %rbp,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1323 <raop_prepare_alac+0x1d3>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %rbp,0x8(%rsp)
add    $0x1,%rbx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     132a <raop_prepare_alac+0x1da>
mov    %rax,%rbp
movb   $0x0,(%rax)
mov    %rbx,0x10(%rsp)
add    $0x1,%rbp
mov    %rbp,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1331 <raop_prepare_alac+0x1e1>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %rbp,0x18(%rsp)
add    $0x1,%rbx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1338 <raop_prepare_alac+0x1e8>
mov    %rax,%rbp
movb   $0x0,(%rax)
mov    %rbx,0x20(%rsp)
add    $0x1,%rbp
mov    %rbp,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     133f <raop_prepare_alac+0x1ef>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %rbp,0x28(%rsp)
add    $0x1,%rbx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1346 <raop_prepare_alac+0x1f6>
mov    %rax,%rbp
movb   $0x0,(%rax)
mov    %rbx,0x30(%rsp)
add    $0x1,%rbp
mov    %rbp,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     134d <raop_prepare_alac+0x1fd>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %rbp,0x38(%rsp)
add    $0x1,%rbx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1354 <raop_prepare_alac+0x204>
mov    %rax,%rbp
movb   $0x0,(%rax)
mov    %rbx,0x40(%rsp)
add    $0x1,%rbp
mov    %rbp,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     135b <raop_prepare_alac+0x20b>
mov    %rax,%rbx
movb   $0x0,(%rax)
mov    %rbp,0x48(%rsp)
add    $0x1,%rbx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1472 <raop_prepare_alac+0x322>
mov    %rax,%rbp
movb   $0x0,(%rax)
mov    %rbx,0x50(%rsp)
add    $0x1,%rbp
mov    %rbp,%rdi
mov    $0x20,%esi
call   1040 <strchr@plt>
mov    $0xb,%ecx
test   %rax,%rax
je     1360 <raop_prepare_alac+0x210>
movb   $0x0,(%rax)
jmp    1360 <raop_prepare_alac+0x210>
xor    %ecx,%ecx
jmp    1363 <raop_prepare_alac+0x213>
mov    $0x1,%ecx
jmp    1360 <raop_prepare_alac+0x210>
mov    $0x2,%ecx
jmp    1363 <raop_prepare_alac+0x213>
mov    $0x3,%ecx
jmp    1360 <raop_prepare_alac+0x210>
mov    $0x4,%ecx
jmp    1363 <raop_prepare_alac+0x213>
mov    $0x5,%ecx
jmp    1360 <raop_prepare_alac+0x210>
mov    $0x6,%ecx
jmp    1363 <raop_prepare_alac+0x213>
mov    $0x7,%ecx
jmp    1360 <raop_prepare_alac+0x210>
mov    $0x8,%ecx
jmp    1363 <raop_prepare_alac+0x213>
mov    $0x9,%ecx
mov    %rbp,%rbx
mov    %rbx,(%rsp,%rcx,8)
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,0x18(%r13)
test   %r12,%r12
je     1391 <raop_prepare_alac+0x241>
mov    %rbx,%rdi
call   1060 <atol@plt>
mov    %rax,(%r12)
mov    0x10(%rsp),%rdi
call   1070 <atoi@plt>
mov    %al,0x1c(%r13)
mov    0x18(%rsp),%rdi
call   1070 <atoi@plt>
mov    %al,0x1d(%r13)
mov    0x20(%rsp),%rdi
call   1070 <atoi@plt>
mov    %al,0x1e(%r13)
mov    0x28(%rsp),%rdi
call   1070 <atoi@plt>
mov    %al,0x1f(%r13)
mov    0x30(%rsp),%rdi
call   1070 <atoi@plt>
mov    %al,0x20(%r13)
mov    0x38(%rsp),%rbx
mov    %rbx,%rdi
call   1070 <atoi@plt>
mov    %al,0x21(%r13)
test   %r15,%r15
je     13f8 <raop_prepare_alac+0x2a8>
mov    %rbx,%rdi
call   1070 <atoi@plt>
mov    %al,(%r15)
mov    0x40(%rsp),%rdi
call   1070 <atoi@plt>
mov    %rax,%rdi
call   1030 <htons@plt>
mov    %eax,0x22(%r13)
mov    0x48(%rsp),%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,0x24(%r13)
mov    0x50(%rsp),%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,0x28(%r13)
mov    0x58(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <atol@plt>
mov    %rax,%rdi
call   1050 <htonl@plt>
mov    %eax,0x2c(%r13)
test   %r14,%r14
je     1463 <raop_prepare_alac+0x313>
mov    %rbx,%rdi
call   1060 <atol@plt>
mov    %rax,(%r14)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xa,%ecx
jmp    1363 <raop_prepare_alac+0x213>

LLVM IR (-O0):
define void @raop_prepare_alac(i8* %0, i8* %1, i64* %2, i8* %3, i64* %4) {
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i64*
%9 = alloca i8*
%10 = alloca i64*
%11 = alloca [12 x i8*]
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i32
store i8* %0, i8** %6
store i8* %1, i8** %7
store i64* %2, i64** %8
store i8* %3, i8** %9
store i64* %4, i64** %10
%15 = load i8*, i8** %7
store i8* %15, i8** %12
store i32 0, i32* %14
br label %16
16: ; preds = %37, %5
%17 = load i32, i32* %14
%18 = icmp slt i32 %17, 12
br i1 %18, label %19, label %40
19: ; preds = %16
%20 = load i8*, i8** %12
%21 = call i8* @strchr(i8* %20, i8 signext 32)
store i8* %21, i8** %13
%22 = load i8*, i8** %13
%23 = icmp eq i8* %22, null
br i1 %23, label %24, label %29
24: ; preds = %19
%25 = load i8*, i8** %12
%26 = load i32, i32* %14
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 %27
store i8* %25, i8** %28
br label %40
29: ; preds = %19
%30 = load i8*, i8** %13
store i8 0, i8* %30
%31 = load i8*, i8** %12
%32 = load i32, i32* %14
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 %33
store i8* %31, i8** %34
%35 = load i8*, i8** %13
%36 = getelementptr inbounds i8, i8* %35, i64 1
store i8* %36, i8** %12
br label %37
37: ; preds = %29
%38 = load i32, i32* %14
%39 = add nsw i32 %38, 1
store i32 %39, i32* %14
br label %16
40: ; preds = %24, %16
%41 = load i8*, i8** %6
%42 = getelementptr inbounds i8, i8* %41, i64 24
store i8* %42, i8** %6
%43 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 1
%44 = load i8*, i8** %43
%45 = call i64 @atol(i8* %44)
%46 = call i32 @htonl(i64 %45)
%47 = load i8*, i8** %6
%48 = bitcast i8* %47 to i32*
store i32 %46, i32* %48
%49 = load i64*, i64** %10
%50 = icmp ne i64* %49, null
br i1 %50, label %51, label %56
51: ; preds = %40
%52 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 1
%53 = load i8*, i8** %52
%54 = call i64 @atol(i8* %53)
%55 = load i64*, i64** %10
store i64 %54, i64* %55
br label %56
56: ; preds = %51, %40
%57 = load i8*, i8** %6
%58 = getelementptr inbounds i8, i8* %57, i64 4
store i8* %58, i8** %6
%59 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 2
%60 = load i8*, i8** %59
%61 = call i8* @atoi(i8* %60)
%62 = ptrtoint i8* %61 to i8
%63 = load i8*, i8** %6
%64 = getelementptr inbounds i8, i8* %63, i32 1
store i8* %64, i8** %6
store i8 %62, i8* %63
%65 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 3
%66 = load i8*, i8** %65
%67 = call i8* @atoi(i8* %66)
%68 = ptrtoint i8* %67 to i8
%69 = load i8*, i8** %6
%70 = getelementptr inbounds i8, i8* %69, i32 1
store i8* %70, i8** %6
store i8 %68, i8* %69
%71 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 4
%72 = load i8*, i8** %71
%73 = call i8* @atoi(i8* %72)
%74 = ptrtoint i8* %73 to i8
%75 = load i8*, i8** %6
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %6
store i8 %74, i8* %75
%77 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 5
%78 = load i8*, i8** %77
%79 = call i8* @atoi(i8* %78)
%80 = ptrtoint i8* %79 to i8
%81 = load i8*, i8** %6
%82 = getelementptr inbounds i8, i8* %81, i32 1
store i8* %82, i8** %6
store i8 %80, i8* %81
%83 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 6
%84 = load i8*, i8** %83
%85 = call i8* @atoi(i8* %84)
%86 = ptrtoint i8* %85 to i8
%87 = load i8*, i8** %6
%88 = getelementptr inbounds i8, i8* %87, i32 1
store i8* %88, i8** %6
store i8 %86, i8* %87
%89 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 7
%90 = load i8*, i8** %89
%91 = call i8* @atoi(i8* %90)
%92 = ptrtoint i8* %91 to i8
%93 = load i8*, i8** %6
%94 = getelementptr inbounds i8, i8* %93, i32 1
store i8* %94, i8** %6
store i8 %92, i8* %93
%95 = load i8*, i8** %9
%96 = icmp ne i8* %95, null
br i1 %96, label %97, label %103
97: ; preds = %56
%98 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 7
%99 = load i8*, i8** %98
%100 = call i8* @atoi(i8* %99)
%101 = ptrtoint i8* %100 to i8
%102 = load i8*, i8** %9
store i8 %101, i8* %102
br label %103
103: ; preds = %97, %56
%104 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 8
%105 = load i8*, i8** %104
%106 = call i8* @atoi(i8* %105)
%107 = call i32 @htons(i8* %106)
%108 = load i8*, i8** %6
%109 = bitcast i8* %108 to i32*
store i32 %107, i32* %109
%110 = load i8*, i8** %6
%111 = getelementptr inbounds i8, i8* %110, i64 2
store i8* %111, i8** %6
%112 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 9
%113 = load i8*, i8** %112
%114 = call i64 @atol(i8* %113)
%115 = call i32 @htonl(i64 %114)
%116 = load i8*, i8** %6
%117 = bitcast i8* %116 to i32*
store i32 %115, i32* %117
%118 = load i8*, i8** %6
%119 = getelementptr inbounds i8, i8* %118, i64 4
store i8* %119, i8** %6
%120 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 10
%121 = load i8*, i8** %120
%122 = call i64 @atol(i8* %121)
%123 = call i32 @htonl(i64 %122)
%124 = load i8*, i8** %6
%125 = bitcast i8* %124 to i32*
store i32 %123, i32* %125
%126 = load i8*, i8** %6
%127 = getelementptr inbounds i8, i8* %126, i64 4
store i8* %127, i8** %6
%128 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 11
%129 = load i8*, i8** %128
%130 = call i64 @atol(i8* %129)
%131 = call i32 @htonl(i64 %130)
%132 = load i8*, i8** %6
%133 = bitcast i8* %132 to i32*
store i32 %131, i32* %133
%134 = load i64*, i64** %8
%135 = icmp ne i64* %134, null
br i1 %135, label %136, label %141
136: ; preds = %103
%137 = getelementptr inbounds [12 x i8*], [12 x i8*]* %11, i64 0, i64 11
%138 = load i8*, i8** %137
%139 = call i64 @atol(i8* %138)
%140 = load i64*, i64** %8
store i64 %139, i64* %140
br label %141
141: ; preds = %136, %103
ret void
}

LLVM IR (-O2):
define void @raop_prepare_alac(i8* nocapture writeonly %0, i8* %1, i64* writeonly %2, i8* writeonly %3, i64* writeonly %4) {
%6 = alloca [12 x i8*]
%7 = bitcast [12 x i8*]* %6 to i8*
%8 = tail call i8* @strchr(i8* dereferenceable(1) %1, i8 signext 32)
%9 = icmp eq i8* %8, null
br i1 %9, label %66, label %10
10: ; preds = %5
store i8 0, i8* %8
%11 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 0
store i8* %1, i8** %11
%12 = getelementptr inbounds i8, i8* %8, i64 1
%13 = tail call i8* @strchr(i8* dereferenceable(1) %12, i8 signext 32)
%14 = icmp eq i8* %13, null
br i1 %14, label %66, label %15
15: ; preds = %10
store i8 0, i8* %13
%16 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 1
store i8* %12, i8** %16
%17 = getelementptr inbounds i8, i8* %13, i64 1
%18 = tail call i8* @strchr(i8* dereferenceable(1) %17, i8 signext 32)
%19 = icmp eq i8* %18, null
br i1 %19, label %66, label %20
20: ; preds = %15
store i8 0, i8* %18
%21 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 2
store i8* %17, i8** %21
%22 = getelementptr inbounds i8, i8* %18, i64 1
%23 = tail call i8* @strchr(i8* dereferenceable(1) %22, i8 signext 32)
%24 = icmp eq i8* %23, null
br i1 %24, label %66, label %25
25: ; preds = %20
store i8 0, i8* %23
%26 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 3
store i8* %22, i8** %26
%27 = getelementptr inbounds i8, i8* %23, i64 1
%28 = tail call i8* @strchr(i8* dereferenceable(1) %27, i8 signext 32)
%29 = icmp eq i8* %28, null
br i1 %29, label %66, label %30
30: ; preds = %25
store i8 0, i8* %28
%31 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 4
store i8* %27, i8** %31
%32 = getelementptr inbounds i8, i8* %28, i64 1
%33 = tail call i8* @strchr(i8* dereferenceable(1) %32, i8 signext 32)
%34 = icmp eq i8* %33, null
br i1 %34, label %66, label %35
35: ; preds = %30
store i8 0, i8* %33
%36 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 5
store i8* %32, i8** %36
%37 = getelementptr inbounds i8, i8* %33, i64 1
%38 = tail call i8* @strchr(i8* dereferenceable(1) %37, i8 signext 32)
%39 = icmp eq i8* %38, null
br i1 %39, label %66, label %40
40: ; preds = %35
store i8 0, i8* %38
%41 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 6
store i8* %37, i8** %41
%42 = getelementptr inbounds i8, i8* %38, i64 1
%43 = tail call i8* @strchr(i8* dereferenceable(1) %42, i8 signext 32)
%44 = icmp eq i8* %43, null
br i1 %44, label %66, label %45
45: ; preds = %40
store i8 0, i8* %43
%46 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 7
store i8* %42, i8** %46
%47 = getelementptr inbounds i8, i8* %43, i64 1
%48 = tail call i8* @strchr(i8* dereferenceable(1) %47, i8 signext 32)
%49 = icmp eq i8* %48, null
br i1 %49, label %66, label %50
50: ; preds = %45
store i8 0, i8* %48
%51 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 8
store i8* %47, i8** %51
%52 = getelementptr inbounds i8, i8* %48, i64 1
%53 = tail call i8* @strchr(i8* dereferenceable(1) %52, i8 signext 32)
%54 = icmp eq i8* %53, null
br i1 %54, label %66, label %55
55: ; preds = %50
store i8 0, i8* %53
%56 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 9
store i8* %52, i8** %56
%57 = getelementptr inbounds i8, i8* %53, i64 1
%58 = tail call i8* @strchr(i8* dereferenceable(1) %57, i8 signext 32)
%59 = icmp eq i8* %58, null
br i1 %59, label %66, label %60
60: ; preds = %55
store i8 0, i8* %58
%61 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 10
store i8* %57, i8** %61
%62 = getelementptr inbounds i8, i8* %58, i64 1
%63 = tail call i8* @strchr(i8* dereferenceable(1) %62, i8 signext 32)
%64 = icmp eq i8* %63, null
br i1 %64, label %66, label %65
65: ; preds = %60
store i8 0, i8* %63
br label %66
66: ; preds = %5, %10, %15, %20, %25, %30, %35, %40, %45, %50, %55, %60, %65
%67 = phi i64 [ 11, %65 ], [ 0, %5 ], [ 1, %10 ], [ 2, %15 ], [ 3, %20 ], [ 4, %25 ], [ 5, %30 ], [ 6, %35 ], [ 7, %40 ], [ 8, %45 ], [ 9, %50 ], [ 10, %55 ], [ 11, %60 ]
%68 = phi i8* [ %62, %65 ], [ %1, %5 ], [ %12, %10 ], [ %17, %15 ], [ %22, %20 ], [ %27, %25 ], [ %32, %30 ], [ %37, %35 ], [ %42, %40 ], [ %47, %45 ], [ %52, %50 ], [ %57, %55 ], [ %62, %60 ]
%69 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 %67
store i8* %68, i8** %69
%70 = getelementptr inbounds i8, i8* %0, i64 24
%71 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 1
%72 = load i8*, i8** %71
%73 = tail call i64 @atol(i8* %72)
%74 = tail call i32 @htonl(i64 %73)
%75 = bitcast i8* %70 to i32*
store i32 %74, i32* %75
%76 = icmp eq i64* %4, null
br i1 %76, label %79, label %77
77: ; preds = %66
%78 = tail call i64 @atol(i8* %72)
store i64 %78, i64* %4
br label %79
79: ; preds = %77, %66
%80 = getelementptr inbounds i8, i8* %0, i64 28
%81 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 2
%82 = load i8*, i8** %81
%83 = tail call i8* @atoi(i8* %82)
%84 = ptrtoint i8* %83 to i64
%85 = trunc i64 %84 to i8
%86 = getelementptr inbounds i8, i8* %0, i64 29
store i8 %85, i8* %80
%87 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 3
%88 = load i8*, i8** %87
%89 = tail call i8* @atoi(i8* %88)
%90 = ptrtoint i8* %89 to i64
%91 = trunc i64 %90 to i8
%92 = getelementptr inbounds i8, i8* %0, i64 30
store i8 %91, i8* %86
%93 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 4
%94 = load i8*, i8** %93
%95 = tail call i8* @atoi(i8* %94)
%96 = ptrtoint i8* %95 to i64
%97 = trunc i64 %96 to i8
%98 = getelementptr inbounds i8, i8* %0, i64 31
store i8 %97, i8* %92
%99 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 5
%100 = load i8*, i8** %99
%101 = tail call i8* @atoi(i8* %100)
%102 = ptrtoint i8* %101 to i64
%103 = trunc i64 %102 to i8
%104 = getelementptr inbounds i8, i8* %0, i64 32
store i8 %103, i8* %98
%105 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 6
%106 = load i8*, i8** %105
%107 = tail call i8* @atoi(i8* %106)
%108 = ptrtoint i8* %107 to i64
%109 = trunc i64 %108 to i8
%110 = getelementptr inbounds i8, i8* %0, i64 33
store i8 %109, i8* %104
%111 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 7
%112 = load i8*, i8** %111
%113 = tail call i8* @atoi(i8* %112)
%114 = ptrtoint i8* %113 to i64
%115 = trunc i64 %114 to i8
%116 = getelementptr inbounds i8, i8* %0, i64 34
store i8 %115, i8* %110
%117 = icmp eq i8* %3, null
br i1 %117, label %122, label %118
118: ; preds = %79
%119 = tail call i8* @atoi(i8* %112)
%120 = ptrtoint i8* %119 to i64
%121 = trunc i64 %120 to i8
store i8 %121, i8* %3
br label %122
122: ; preds = %118, %79
%123 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 8
%124 = load i8*, i8** %123
%125 = tail call i8* @atoi(i8* %124)
%126 = tail call i32 @htons(i8* %125)
%127 = bitcast i8* %116 to i32*
store i32 %126, i32* %127
%128 = getelementptr inbounds i8, i8* %0, i64 36
%129 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 9
%130 = load i8*, i8** %129
%131 = tail call i64 @atol(i8* %130)
%132 = tail call i32 @htonl(i64 %131)
%133 = bitcast i8* %128 to i32*
store i32 %132, i32* %133
%134 = getelementptr inbounds i8, i8* %0, i64 40
%135 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 10
%136 = load i8*, i8** %135
%137 = tail call i64 @atol(i8* %136)
%138 = tail call i32 @htonl(i64 %137)
%139 = bitcast i8* %134 to i32*
store i32 %138, i32* %139
%140 = getelementptr inbounds i8, i8* %0, i64 44
%141 = getelementptr inbounds [12 x i8*], [12 x i8*]* %6, i64 0, i64 11
%142 = load i8*, i8** %141
%143 = tail call i64 @atol(i8* %142)
%144 = tail call i32 @htonl(i64 %143)
%145 = bitcast i8* %140 to i32*
store i32 %144, i32* %145
%146 = icmp eq i64* %2, null
br i1 %146, label %149, label %147
147: ; preds = %122
%148 = tail call i64 @atol(i8* %142)
store i64 %148, i64* %2
br label %149
149: ; preds = %147, %122
ret void
}