#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 *);
int /*<<< orphan*/ parse_string(char *, char *, char *, int);
int /*<<< orphan*/
printf(char *, unsigned long, unsigned 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_pool(char *s) {
  char pool_type[3];
  unsigned long cli_id = parse(s, "CI");
  unsigned long pool_id = parse(s, "PI");
  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);
  if (pool_type[1] == 'S')
    return;
  printf("domid%lu,id%lu[%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",
         cli_id, pool_id, pool_type, 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_pool>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
mov    %rdi,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xead(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe9c(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe8b(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe7a(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe69(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe58(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x68(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe47(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe36(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x78(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe25(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe14(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x88(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xe00(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x90(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdec(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0x98(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdd8(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdc4(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xdb0(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd9c(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xb8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd88(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd74(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x30(%rbp),%rdi
lea    0xd60(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x30(%rbp),%rdi
lea    -0x33(%rbp),%rdx
lea    0xd48(%rip),%rsi
mov    $0x2,%ecx
call   1030 <parse_string@plt>
movsbl -0x32(%rbp),%eax
cmp    $0x53,%eax
jne    130d <parse_pool+0x1dd>
jmp    14f8 <parse_pool+0x3c8>
mov    -0x40(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x148(%rbp)
lea    -0x33(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
cmpq   $0x0,-0xb0(%rbp)
je     13fc <parse_pool+0x2cc>
imul   $0x64,-0xa8(%rbp),%rax
64
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0xb0(%rbp)
mov    %rax,-0x158(%rbp)
jmp    140a <parse_pool+0x2da>
xor    %eax,%eax
mov    %rax,-0x158(%rbp)
jmp    140a <parse_pool+0x2da>
mov    -0xe0(%rbp),%r12
mov    -0xe8(%rbp),%r13
mov    -0x128(%rbp),%r15
mov    -0x130(%rbp),%r9
mov    -0x138(%rbp),%r8
mov    -0x140(%rbp),%rcx
mov    -0x148(%rbp),%rdx
mov    -0x150(%rbp),%rsi
mov    -0x158(%rbp),%r14
mov    -0xb8(%rbp),%rbx
mov    -0xc0(%rbp),%r11
mov    -0xc8(%rbp),%r10
mov    -0xd0(%rbp),%rax
lea    0xbd0(%rip),%rdi
mov    %r15,(%rsp)
mov    -0x120(%rbp),%r15
mov    %r15,0x8(%rsp)
mov    -0x118(%rbp),%r15
mov    %r15,0x10(%rsp)
mov    -0x110(%rbp),%r15
mov    %r15,0x18(%rsp)
mov    -0x108(%rbp),%r15
mov    %r15,0x20(%rsp)
mov    -0x100(%rbp),%r15
mov    %r15,0x28(%rsp)
mov    -0xf8(%rbp),%r15
mov    %r15,0x30(%rsp)
mov    -0xf0(%rbp),%r15
mov    %r15,0x38(%rsp)
mov    -0xd8(%rbp),%r15
mov    %r13,0x40(%rsp)
mov    %r12,0x48(%rsp)
mov    %r15,0x50(%rsp)
mov    %r14,0x58(%rsp)
mov    %rbx,0x60(%rsp)
mov    %r11,0x68(%rsp)
mov    %r10,0x70(%rsp)
mov    %rax,0x78(%rsp)
call   1040 <printf@plt>
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_pool>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rdi,%r14
lea    0xeb8(%rip),%rsi
call   1050 <parse@plt>
mov    %rax,%rbp
lea    0xeac(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x28(%rsp)
lea    0xe9b(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x20(%rsp)
lea    0xe8a(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%rbx
lea    0xe7b(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x38(%rsp)
lea    0xe6a(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x30(%rsp)
lea    0xe59(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x18(%rsp)
lea    0xe48(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x10(%rsp)
lea    0xe37(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x8(%rsp)
lea    0xe26(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x70(%rsp)
lea    0xe15(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x68(%rsp)
lea    0xe04(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x60(%rsp)
lea    0xdf3(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x58(%rsp)
lea    0xde2(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x40(%rsp)
lea    0xdd1(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%r13
lea    0xdc2(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x50(%rsp)
lea    0xdb1(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,0x48(%rsp)
lea    0xda0(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%r15
lea    0xd91(%rip),%rsi
mov    %r14,%rdi
call   1050 <parse@plt>
mov    %rax,%r12
lea    0xd82(%rip),%rsi
lea    0x5(%rsp),%rdx
mov    %r14,%rdi
mov    $0x2,%ecx
call   1030 <parse_string@plt>
cmpb   $0x53,0x6(%rsp)
je     1373 <parse_pool+0x243>
mov    %rbx,%r9
mov    %rbp,%rsi
test   %r13,%r13
je     12f8 <parse_pool+0x1c8>
imul   $0x64,0x40(%rsp),%rax
mov    %r13,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
je     12fc <parse_pool+0x1cc>
xor    %edx,%edx
div    %r13
jmp    1301 <parse_pool+0x1d1>
xor    %eax,%eax
jmp    1301 <parse_pool+0x1d1>
xor    %edx,%edx
div    %r13d
mov    0x38(%rsp),%r10
mov    0x30(%rsp),%r11
mov    0x28(%rsp),%rdx
mov    0x20(%rsp),%r8
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%rbp
mov    0x8(%rsp),%rbx
lea    0xd11(%rip),%rdi
lea    0x5(%rsp),%rcx
push   %r12
push   %r15
push   0x58(%rsp)
push   0x68(%rsp)
push   %rax
push   %r13
push   0x70(%rsp)
push   0x90(%rsp)
push   0xa0(%rsp)
push   0xb0(%rsp)
push   0xc0(%rsp)
push   %rbx
push   %rbp
push   %r14
push   %r11
push   %r10
call   1040 <printf@plt>
add    $0x80,%rsp
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"CI\00"
@.str.1 = [3 x i8] c"PI\00"
@.str.2 = [3 x i8] c"Pc\00"
@.str.3 = [3 x i8] c"Pm\00"
@.str.4 = [3 x i8] c"Oc\00"
@.str.5 = [3 x i8] c"Om\00"
@.str.6 = [3 x i8] c"Nc\00"
@.str.7 = [3 x i8] c"Nm\00"
@.str.8 = [3 x i8] c"ps\00"
@.str.9 = [3 x i8] c"pt\00"
@.str.10 = [3 x i8] c"px\00"
@.str.11 = [3 x i8] c"pd\00"
@.str.12 = [3 x i8] c"pr\00"
@.str.13 = [3 x i8] c"gs\00"
@.str.14 = [3 x i8] c"gt\00"
@.str.15 = [3 x i8] c"fs\00"
@.str.16 = [3 x i8] c"ft\00"
@.str.17 = [3 x i8] c"os\00"
@.str.18 = [3 x i8] c"ot\00"
@.str.19 = [3 x i8] c"PT\00"
@.str.20 = [163 x i8] c"domid%lu,id%lu[%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_pool(i8* %0) {
%2 = alloca i8*
%3 = alloca [3 x i8]
%4 = alloca i64
%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
store i8* %0, i8** %2
%23 = load i8*, i8** %2
%24 = call i8* @parse(i8* %23, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%25 = ptrtoint i8* %24 to i64
store i64 %25, i64* %4
%26 = load i8*, i8** %2
%27 = call i8* @parse(i8* %26, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%28 = ptrtoint i8* %27 to i64
store i64 %28, i64* %5
%29 = load i8*, i8** %2
%30 = call i8* @parse(i8* %29, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%31 = ptrtoint i8* %30 to i64
store i64 %31, i64* %6
%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* %7
%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* %8
%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* %9
%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* %10
%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* %11
%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* %12
%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* %13
%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* %14
%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* %15
%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* %16
%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* %17
%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* %18
%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* %19
%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* %20
%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* %21
%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* %22
%80 = load i8*, i8** %2
%81 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 0
%82 = call i32 @parse_string(i8* %80, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0), i8* %81, i32 2)
%83 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 1
%84 = load i8, i8* %83
%85 = sext i8 %84 to i32
%86 = icmp eq i32 %85, 83
br i1 %86, label %87, label %88
87: ; preds = %1
br label %120
88: ; preds = %1
%89 = load i64, i64* %4
%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 = load i64, i64* %8
%95 = load i64, i64* %9
%96 = load i64, i64* %10
%97 = load i64, i64* %11
%98 = load i64, i64* %12
%99 = load i64, i64* %13
%100 = load i64, i64* %14
%101 = load i64, i64* %15
%102 = load i64, i64* %16
%103 = load i64, i64* %17
%104 = load i64, i64* %18
%105 = load i64, i64* %18
%106 = icmp ne i64 %105, 0
br i1 %106, label %107, label %112
107: ; preds = %88
%108 = load i64, i64* %17
%109 = mul i64 %108, 100
%110 = load i64, i64* %18
%111 = udiv i64 %109, %110
br label %113
112: ; preds = %88
br label %113
113: ; preds = %112, %107
%114 = phi i64 [ %111, %107 ], [ 0, %112 ]
%115 = load i64, i64* %19
%116 = load i64, i64* %20
%117 = load i64, i64* %21
%118 = load i64, i64* %22
%119 = call i32 @printf(i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.20, i64 0, i64 0), i64 %89, i64 %90, i8* %91, i64 %92, i64 %93, i64 %94, i64 %95, i64 %96, i64 %97, i64 %98, i64 %99, i64 %100, i64 %101, i64 %102, i64 %103, i64 %104, i64 %114, i64 %115, i64 %116, i64 %117, i64 %118)
br label %120
120: ; preds = %113, %87
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c"CI\00"
@.str.1 = [3 x i8] c"PI\00"
@.str.2 = [3 x i8] c"Pc\00"
@.str.3 = [3 x i8] c"Pm\00"
@.str.4 = [3 x i8] c"Oc\00"
@.str.5 = [3 x i8] c"Om\00"
@.str.6 = [3 x i8] c"Nc\00"
@.str.7 = [3 x i8] c"Nm\00"
@.str.8 = [3 x i8] c"ps\00"
@.str.9 = [3 x i8] c"pt\00"
@.str.10 = [3 x i8] c"px\00"
@.str.11 = [3 x i8] c"pd\00"
@.str.12 = [3 x i8] c"pr\00"
@.str.13 = [3 x i8] c"gs\00"
@.str.14 = [3 x i8] c"gt\00"
@.str.15 = [3 x i8] c"fs\00"
@.str.16 = [3 x i8] c"ft\00"
@.str.17 = [3 x i8] c"os\00"
@.str.18 = [3 x i8] c"ot\00"
@.str.19 = [3 x i8] c"PT\00"
@.str.20 = [163 x i8] c"domid%lu,id%lu[%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_pool(i8* %0) {
%2 = alloca [3 x i8]
%3 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 0
%4 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%5 = ptrtoint i8* %4 to i64
%6 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%7 = ptrtoint i8* %6 to i64
%8 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%9 = ptrtoint i8* %8 to i64
%10 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%11 = ptrtoint i8* %10 to i64
%12 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%13 = ptrtoint i8* %12 to i64
%14 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%15 = ptrtoint i8* %14 to i64
%16 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%17 = ptrtoint i8* %16 to i64
%18 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0))
%19 = ptrtoint i8* %18 to i64
%20 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, 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.9, 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.10, i64 0, i64 0))
%25 = ptrtoint i8* %24 to i64
%26 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
%27 = ptrtoint i8* %26 to i64
%28 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
%29 = ptrtoint i8* %28 to i64
%30 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%31 = ptrtoint i8* %30 to i64
%32 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0))
%33 = ptrtoint i8* %32 to i64
%34 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0))
%35 = ptrtoint i8* %34 to i64
%36 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0))
%37 = ptrtoint i8* %36 to i64
%38 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0))
%39 = ptrtoint i8* %38 to i64
%40 = tail call i8* @parse(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0))
%41 = ptrtoint i8* %40 to i64
%42 = call i32 @parse_string(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0), i8* %3, i32 2)
%43 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 1
%44 = load i8, i8* %43
%45 = icmp eq i8 %44, 83
br i1 %45, label %54, label %46
46: ; preds = %1
%47 = icmp eq i8* %32, null
br i1 %47, label %51, label %48
48: ; preds = %46
%49 = mul i64 %31, 100
%50 = udiv i64 %49, %33
br label %51
51: ; preds = %46, %48
%52 = phi i64 [ %50, %48 ], [ 0, %46 ]
%53 = call i32 @printf(i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.20, i64 0, i64 0), i64 %5, i64 %7, i8* %3, i64 %9, i64 %11, i64 %13, i64 %15, i64 %17, i64 %19, i64 %21, i64 %23, i64 %25, i64 %27, i64 %29, i64 %31, i64 %33, i64 %52, i64 %35, i64 %37, i64 %39, i64 %41)
br label %54
54: ; preds = %1, %51
ret void
}