#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 */
void *parse(char *, char *);
unsigned long long parse_hex(char *, char *);
int /*<<< orphan*/ parse_sharers(char *, char *, char *, int);
int /*<<< orphan*/ parse_string(char *, char *, char *, int);
int /*<<< orphan*/
printf(char *, unsigned long, char *, unsigned long long, unsigned long long,
       char *, unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long,
       unsigned long long, unsigned long long, unsigned long long);
void parse_shared_pool(char *s) {
  char pool_type[3];
  char buf[4096];
  unsigned long pool_id = parse(s, "PI");
  unsigned long long uid0 = parse_hex(s, "U0");
  unsigned long long uid1 = parse_hex(s, "U1");
  unsigned long long pgp_count = parse(s, "Pc");
  unsigned long long max_pgp_count = parse(s, "Pm");
  unsigned long long obj_count = parse(s, "Oc");
  unsigned long long max_obj_count = parse(s, "Om");
  unsigned long long objnode_count = parse(s, "Nc");
  unsigned long long max_objnode_count = parse(s, "Nm");
  unsigned long long good_puts = parse(s, "ps");
  unsigned long long puts = parse(s, "pt");
  unsigned long long no_mem_puts = parse(s, "px");
  unsigned long long dup_puts_flushed = parse(s, "pd");
  unsigned long long dup_puts_replaced = parse(s, "pr");
  unsigned long long found_gets = parse(s, "gs");
  unsigned long long gets = parse(s, "gt");
  unsigned long long flushs_found = parse(s, "fs");
  unsigned long long flushs = parse(s, "ft");
  unsigned long long flush_objs_found = parse(s, "os");
  unsigned long long flush_objs = parse(s, "ot");
  parse_string(s, "PT", pool_type, 2);
  pool_type[2] = '\0';
  parse_sharers(s, "SC", buf, 4096);
  printf("poolid=%lu[%s] uuid=%llx.%llx, shared-by:%s: "
         "pgp=%llu(max=%llu) obj=%llu(%llu) "
         "objnode=%llu(%llu) puts=%llu/%llu/%llu(dup=%llu/%llu) "
         "gets=%llu/%llu(%llu%%) "
         "flush=%llu/%llu flobj=%llu/%llu\n",
         pool_id, pool_type, uid0, uid1, buf, pgp_count, max_pgp_count,
         obj_count, max_obj_count, objnode_count, max_objnode_count, good_puts,
         puts, no_mem_puts, dup_puts_flushed, dup_puts_replaced, found_gets,
         gets, gets ? (found_gets * 100LL) / gets : 0, flushs_found, flushs,
         flush_objs_found, flush_objs);
}


x86 assembly (clang, -O0):
<parse_shared_pool>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x11e8,%rsp
mov    %rdi,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe8d(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1048(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe79(%rip),%rsi
call   1060 <parse_hex@plt>
mov    %rax,-0x1050(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe65(%rip),%rsi
call   1060 <parse_hex@plt>
mov    %rax,-0x1058(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe51(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1060(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe3d(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1068(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe29(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1070(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe15(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1078(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe01(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1080(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xded(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1088(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdd9(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1090(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdc5(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x1098(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdb1(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10a0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd9d(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10a8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd89(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10b0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd75(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10b8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd61(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10c0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd4d(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10c8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd39(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10d0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd25(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10d8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd11(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,-0x10e0(%rbp)
mov    -0x30(%rbp),%rdi
lea    -0x33(%rbp),%rdx
lea    0xcf9(%rip),%rsi
mov    $0x2,%ecx
call   1030 <parse_string@plt>
movb   $0x0,-0x31(%rbp)
mov    -0x30(%rbp),%rdi
lea    -0x1040(%rbp),%rdx
lea    0xcdc(%rip),%rsi
mov    $0x1000,%ecx
call   1050 <parse_sharers@plt>
mov    -0x1048(%rbp),%rax
mov    %rax,-0x1170(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0x1168(%rbp)
mov    -0x1050(%rbp),%rax
mov    %rax,-0x1160(%rbp)
mov    -0x1058(%rbp),%rax
mov    %rax,-0x1158(%rbp)
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1150(%rbp)
mov    -0x1060(%rbp),%rax
mov    %rax,-0x1148(%rbp)
mov    -0x1068(%rbp),%rax
mov    %rax,-0x1140(%rbp)
mov    -0x1070(%rbp),%rax
mov    %rax,-0x1138(%rbp)
mov    -0x1078(%rbp),%rax
mov    %rax,-0x1130(%rbp)
mov    -0x1080(%rbp),%rax
mov    %rax,-0x1128(%rbp)
mov    -0x1088(%rbp),%rax
mov    %rax,-0x1120(%rbp)
mov    -0x1090(%rbp),%rax
mov    %rax,-0x1118(%rbp)
mov    -0x1098(%rbp),%rax
mov    %rax,-0x1110(%rbp)
mov    -0x10a0(%rbp),%rax
mov    %rax,-0x1108(%rbp)
mov    -0x10a8(%rbp),%rax
mov    %rax,-0x1100(%rbp)
mov    -0x10b0(%rbp),%rax
mov    %rax,-0x10f8(%rbp)
mov    -0x10b8(%rbp),%rax
mov    %rax,-0x10f0(%rbp)
mov    -0x10c0(%rbp),%rax
mov    %rax,-0x10e8(%rbp)
cmpq   $0x0,-0x10c0(%rbp)
je     1493 <parse_shared_pool+0x343>
imul   $0x64,-0x10b8(%rbp),%rax
64
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x10c0(%rbp)
mov    %rax,-0x1178(%rbp)
jmp    14a1 <parse_shared_pool+0x351>
xor    %eax,%eax
mov    %rax,-0x1178(%rbp)
jmp    14a1 <parse_shared_pool+0x351>
mov    -0x10f0(%rbp),%r12
mov    -0x10f8(%rbp),%r13
mov    -0x1148(%rbp),%r15
mov    -0x1150(%rbp),%r9
mov    -0x1158(%rbp),%r8
mov    -0x1160(%rbp),%rcx
mov    -0x1168(%rbp),%rdx
mov    -0x1170(%rbp),%rsi
mov    -0x1178(%rbp),%r14
mov    -0x10c8(%rbp),%rbx
mov    -0x10d0(%rbp),%r11
mov    -0x10d8(%rbp),%r10
mov    -0x10e0(%rbp),%rax
lea    0xb3f(%rip),%rdi
mov    %r15,(%rsp)
mov    -0x1140(%rbp),%r15
mov    %r15,0x8(%rsp)
mov    -0x1138(%rbp),%r15
mov    %r15,0x10(%rsp)
mov    -0x1130(%rbp),%r15
mov    %r15,0x18(%rsp)
mov    -0x1128(%rbp),%r15
mov    %r15,0x20(%rsp)
mov    -0x1120(%rbp),%r15
mov    %r15,0x28(%rsp)
mov    -0x1118(%rbp),%r15
mov    %r15,0x30(%rsp)
mov    -0x1110(%rbp),%r15
mov    %r15,0x38(%rsp)
mov    -0x1108(%rbp),%r15
mov    %r15,0x40(%rsp)
mov    -0x1100(%rbp),%r15
mov    %r15,0x48(%rsp)
mov    -0x10e8(%rbp),%r15
mov    %r13,0x50(%rsp)
mov    %r12,0x58(%rsp)
mov    %r15,0x60(%rsp)
mov    %r14,0x68(%rsp)
mov    %rbx,0x70(%rsp)
mov    %r11,0x78(%rsp)
mov    %r10,0x80(%rsp)
mov    %rax,0x88(%rsp)
call   1040 <printf@plt>
add    $0x11e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_shared_pool>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1088,%rsp
mov    %rdi,%r13
lea    0xe95(%rip),%rsi
call   1070 <parse@plt>
mov    %rax,0x20(%rsp)
lea    0xe87(%rip),%rsi
mov    %r13,%rdi
call   1060 <parse_hex@plt>
mov    %rax,0x10(%rsp)
lea    0xe76(%rip),%rsi
mov    %r13,%rdi
call   1060 <parse_hex@plt>
mov    %rax,0x8(%rsp)
lea    0xe65(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x30(%rsp)
lea    0xe54(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x28(%rsp)
lea    0xe43(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x18(%rsp)
lea    0xe32(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,%rbx
lea    0xe23(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x78(%rsp)
lea    0xe12(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x70(%rsp)
lea    0xe01(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x68(%rsp)
lea    0xdf0(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x60(%rsp)
lea    0xddf(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x58(%rsp)
lea    0xdce(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x50(%rsp)
lea    0xdbd(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x48(%rsp)
lea    0xdac(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,%r15
lea    0xd9d(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,%rbp
lea    0xd8e(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x40(%rsp)
lea    0xd7d(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,0x38(%rsp)
lea    0xd6c(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,%r12
lea    0xd5d(%rip),%rsi
mov    %r13,%rdi
call   1070 <parse@plt>
mov    %rax,%r14
lea    0xd4e(%rip),%rsi
lea    0x5(%rsp),%rdx
mov    %r13,%rdi
mov    $0x2,%ecx
call   1030 <parse_string@plt>
movb   $0x0,0x7(%rsp)
lea    0xd33(%rip),%rsi
lea    0x80(%rsp),%rdx
mov    %r13,%rdi
mov    $0x1000,%ecx
call   1050 <parse_sharers@plt>
mov    %rbx,%r13
test   %rbp,%rbp
je     1340 <parse_shared_pool+0x1f0>
imul   $0x64,%r15,%rax
mov    %rbp,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     1344 <parse_shared_pool+0x1f4>
xor    %edx,%edx
div    %rbp
jmp    1348 <parse_shared_pool+0x1f8>
xor    %eax,%eax
jmp    1348 <parse_shared_pool+0x1f8>
xor    %edx,%edx
div    %ebp
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%rcx
mov    0x8(%rsp),%r8
lea    0xcd5(%rip),%rdi
lea    0x5(%rsp),%rdx
lea    0x80(%rsp),%r9
push   %r14
push   %r12
push   0x48(%rsp)
push   0x58(%rsp)
push   %rax
push   %rbp
push   %r15
push   0x80(%rsp)
push   0x90(%rsp)
push   0xa0(%rsp)
push   0xb0(%rsp)
push   0xc0(%rsp)
push   0xd0(%rsp)
push   0xe0(%rsp)
push   %r13
push   %rbx
push   %r11
push   %r10
call   1040 <printf@plt>
add    $0x1118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"PI\00"
@.str.1 = [3 x i8] c"U0\00"
@.str.2 = [3 x i8] c"U1\00"
@.str.3 = [3 x i8] c"Pc\00"
@.str.4 = [3 x i8] c"Pm\00"
@.str.5 = [3 x i8] c"Oc\00"
@.str.6 = [3 x i8] c"Om\00"
@.str.7 = [3 x i8] c"Nc\00"
@.str.8 = [3 x i8] c"Nm\00"
@.str.9 = [3 x i8] c"ps\00"
@.str.10 = [3 x i8] c"pt\00"
@.str.11 = [3 x i8] c"px\00"
@.str.12 = [3 x i8] c"pd\00"
@.str.13 = [3 x i8] c"pr\00"
@.str.14 = [3 x i8] c"gs\00"
@.str.15 = [3 x i8] c"gt\00"
@.str.16 = [3 x i8] c"fs\00"
@.str.17 = [3 x i8] c"ft\00"
@.str.18 = [3 x i8] c"os\00"
@.str.19 = [3 x i8] c"ot\00"
@.str.20 = [3 x i8] c"PT\00"
@.str.21 = [3 x i8] c"SC\00"
@.str.22 = [189 x i8] c"poolid=%lu[%s] uuid=%llx.%llx, shared-by:%s: pgp=%llu(max=%llu) obj=%llu(%llu) objnode=%llu(%llu) puts=%llu/%llu/%llu(dup=%llu/%llu) gets=%llu/%llu(%llu%%) flush=%llu/%llu flobj=%llu/%llu\0A\00"
define void @parse_shared_pool(i8* %0) {
%2 = alloca i8*
%3 = alloca [3 x i8]
%4 = alloca [4096 x i8]
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
store i8* %0, i8** %2
%25 = load i8*, i8** %2
%26 = call i8* @parse(i8* %25, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%27 = ptrtoint i8* %26 to i64
store i64 %27, i64* %5
%28 = load i8*, i8** %2
%29 = call i64 @parse_hex(i8* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i64 %29, i64* %6
%30 = load i8*, i8** %2
%31 = call i64 @parse_hex(i8* %30, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
store i64 %31, i64* %7
%32 = load i8*, i8** %2
%33 = call i8* @parse(i8* %32, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%34 = ptrtoint i8* %33 to i64
store i64 %34, i64* %8
%35 = load i8*, i8** %2
%36 = call i8* @parse(i8* %35, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%37 = ptrtoint i8* %36 to i64
store i64 %37, i64* %9
%38 = load i8*, i8** %2
%39 = call i8* @parse(i8* %38, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%40 = ptrtoint i8* %39 to i64
store i64 %40, i64* %10
%41 = load i8*, i8** %2
%42 = call i8* @parse(i8* %41, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%43 = ptrtoint i8* %42 to i64
store i64 %43, i64* %11
%44 = load i8*, i8** %2
%45 = call i8* @parse(i8* %44, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
%46 = ptrtoint i8* %45 to i64
store i64 %46, i64* %12
%47 = load i8*, i8** %2
%48 = call i8* @parse(i8* %47, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%49 = ptrtoint i8* %48 to i64
store i64 %49, i64* %13
%50 = load i8*, i8** %2
%51 = call i8* @parse(i8* %50, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0))
%52 = ptrtoint i8* %51 to i64
store i64 %52, i64* %14
%53 = load i8*, i8** %2
%54 = call i8* @parse(i8* %53, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
%55 = ptrtoint i8* %54 to i64
store i64 %55, i64* %15
%56 = load i8*, i8** %2
%57 = call i8* @parse(i8* %56, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
%58 = ptrtoint i8* %57 to i64
store i64 %58, i64* %16
%59 = load i8*, i8** %2
%60 = call i8* @parse(i8* %59, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
%61 = ptrtoint i8* %60 to i64
store i64 %61, i64* %17
%62 = load i8*, i8** %2
%63 = call i8* @parse(i8* %62, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%64 = ptrtoint i8* %63 to i64
store i64 %64, i64* %18
%65 = load i8*, i8** %2
%66 = call i8* @parse(i8* %65, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0))
%67 = ptrtoint i8* %66 to i64
store i64 %67, i64* %19
%68 = load i8*, i8** %2
%69 = call i8* @parse(i8* %68, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0))
%70 = ptrtoint i8* %69 to i64
store i64 %70, i64* %20
%71 = load i8*, i8** %2
%72 = call i8* @parse(i8* %71, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%73 = ptrtoint i8* %72 to i64
store i64 %73, i64* %21
%74 = load i8*, i8** %2
%75 = call i8* @parse(i8* %74, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0))
%76 = ptrtoint i8* %75 to i64
store i64 %76, i64* %22
%77 = load i8*, i8** %2
%78 = call i8* @parse(i8* %77, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0))
%79 = ptrtoint i8* %78 to i64
store i64 %79, i64* %23
%80 = load i8*, i8** %2
%81 = call i8* @parse(i8* %80, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0))
%82 = ptrtoint i8* %81 to i64
store i64 %82, i64* %24
%83 = load i8*, i8** %2
%84 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 0
%85 = call i32 @parse_string(i8* %83, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0), i8* %84, i32 2)
%86 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 2
store i8 0, i8* %86
%87 = load i8*, i8** %2
%88 = getelementptr inbounds [4096 x i8], [4096 x i8]* %4, i64 0, i64 0
%89 = call i32 @parse_sharers(i8* %87, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %88, i32 4096)
%90 = load i64, i64* %5
%91 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 0
%92 = load i64, i64* %6
%93 = load i64, i64* %7
%94 = getelementptr inbounds [4096 x i8], [4096 x i8]* %4, i64 0, i64 0
%95 = load i64, i64* %8
%96 = load i64, i64* %9
%97 = load i64, i64* %10
%98 = load i64, i64* %11
%99 = load i64, i64* %12
%100 = load i64, i64* %13
%101 = load i64, i64* %14
%102 = load i64, i64* %15
%103 = load i64, i64* %16
%104 = load i64, i64* %17
%105 = load i64, i64* %18
%106 = load i64, i64* %19
%107 = load i64, i64* %20
%108 = load i64, i64* %20
%109 = icmp ne i64 %108, 0
br i1 %109, label %110, label %115
110: ; preds = %1
%111 = load i64, i64* %19
%112 = mul i64 %111, 100
%113 = load i64, i64* %20
%114 = udiv i64 %112, %113
br label %116
115: ; preds = %1
br label %116
116: ; preds = %115, %110
%117 = phi i64 [ %114, %110 ], [ 0, %115 ]
%118 = load i64, i64* %21
%119 = load i64, i64* %22
%120 = load i64, i64* %23
%121 = load i64, i64* %24
%122 = call i32 @printf(i8* getelementptr inbounds ([189 x i8], [189 x i8]* @.str.22, i64 0, i64 0), i64 %90, i8* %91, i64 %92, i64 %93, i8* %94, i64 %95, i64 %96, i64 %97, i64 %98, i64 %99, i64 %100, i64 %101, i64 %102, i64 %103, i64 %104, i64 %105, i64 %106, i64 %107, i64 %117, i64 %118, i64 %119, i64 %120, i64 %121)
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c"PI\00"
@.str.1 = [3 x i8] c"U0\00"
@.str.2 = [3 x i8] c"U1\00"
@.str.3 = [3 x i8] c"Pc\00"
@.str.4 = [3 x i8] c"Pm\00"
@.str.5 = [3 x i8] c"Oc\00"
@.str.6 = [3 x i8] c"Om\00"
@.str.7 = [3 x i8] c"Nc\00"
@.str.8 = [3 x i8] c"Nm\00"
@.str.9 = [3 x i8] c"ps\00"
@.str.10 = [3 x i8] c"pt\00"
@.str.11 = [3 x i8] c"px\00"
@.str.12 = [3 x i8] c"pd\00"
@.str.13 = [3 x i8] c"pr\00"
@.str.14 = [3 x i8] c"gs\00"
@.str.15 = [3 x i8] c"gt\00"
@.str.16 = [3 x i8] c"fs\00"
@.str.17 = [3 x i8] c"ft\00"
@.str.18 = [3 x i8] c"os\00"
@.str.19 = [3 x i8] c"ot\00"
@.str.20 = [3 x i8] c"PT\00"
@.str.21 = [3 x i8] c"SC\00"
@.str.22 = [189 x i8] c"poolid=%lu[%s] uuid=%llx.%llx, shared-by:%s: pgp=%llu(max=%llu) obj=%llu(%llu) objnode=%llu(%llu) puts=%llu/%llu/%llu(dup=%llu/%llu) gets=%llu/%llu(%llu%%) flush=%llu/%llu flobj=%llu/%llu\0A\00"
define void @parse_shared_pool(i8* %0) {
%2 = alloca [3 x i8]
%3 = alloca [4096 x i8]
%4 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 0
%5 = getelementptr inbounds [4096 x i8], [4096 x i8]* %3, i64 0, i64 0
%6 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%7 = tail call i64 @parse_hex(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%8 = tail call i64 @parse_hex(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%9 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%10 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%11 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%12 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%13 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
%14 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i64 0, i64 0))
%15 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i64 0, i64 0))
%16 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
%17 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
%18 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
%19 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%20 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0))
%21 = ptrtoint i8* %20 to i64
%22 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0))
%23 = ptrtoint i8* %22 to i64
%24 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%25 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0))
%26 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0))
%27 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0))
%28 = call i32 @parse_string(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0), i8* %4, i32 2)
%29 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 2
store i8 0, i8* %29
%30 = call i32 @parse_sharers(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %5, i32 4096)
%31 = icmp eq i8* %22, null
br i1 %31, label %35, label %32
32: ; preds = %1
%33 = mul i64 %21, 100
%34 = udiv i64 %33, %23
br label %35
35: ; preds = %1, %32
%36 = phi i64 [ %34, %32 ], [ 0, %1 ]
%37 = ptrtoint i8* %27 to i64
%38 = ptrtoint i8* %26 to i64
%39 = ptrtoint i8* %25 to i64
%40 = ptrtoint i8* %24 to i64
%41 = ptrtoint i8* %19 to i64
%42 = ptrtoint i8* %18 to i64
%43 = ptrtoint i8* %17 to i64
%44 = ptrtoint i8* %16 to i64
%45 = ptrtoint i8* %15 to i64
%46 = ptrtoint i8* %14 to i64
%47 = ptrtoint i8* %13 to i64
%48 = ptrtoint i8* %12 to i64
%49 = ptrtoint i8* %11 to i64
%50 = ptrtoint i8* %10 to i64
%51 = ptrtoint i8* %9 to i64
%52 = ptrtoint i8* %6 to i64
%53 = call i32 @printf(i8* getelementptr inbounds ([189 x i8], [189 x i8]* @.str.22, i64 0, i64 0), i64 %52, i8* %4, i64 %7, i64 %8, i8* %5, i64 %51, i64 %50, i64 %49, i64 %48, i64 %47, i64 %46, i64 %45, i64 %44, i64 %43, i64 %42, i64 %41, i64 %21, i64 %23, i64 %36, i64 %40, i64 %39, i64 %38, i64 %37)
ret void
}