#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 ph_sinit(int *bsizes, void ***table, void ***keys, int size) {
  int i;
  for (i = 0; i < size; i++) {
    bsizes[i] = 0;
    table[i] = NULL;
    keys[i] = NULL;
  }
  return;
}


x86 assembly (clang, -O0):
<ph_sinit>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1163 <ph_sinit+0x63>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111a <ph_sinit+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<ph_sinit>:
test   %ecx,%ecx
jle    1231 <ph_sinit+0x131>
mov    %ecx,%r9d
cmp    $0x4,%ecx
jb     1126 <ph_sinit+0x26>
lea    (%rdx,%r9,8),%rax
cmp    %rsi,%rax
jbe    119f <ph_sinit+0x9f>
lea    (%rsi,%r9,8),%rax
cmp    %rdx,%rax
jbe    119f <ph_sinit+0x9f>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
test   $0x1,%r9b
je     114f <ph_sinit+0x4f>
movl   $0x0,(%rdi,%rcx,4)
movq   $0x0,(%rsi,%rcx,8)
movq   $0x0,(%rdx,%rcx,8)
or     $0x1,%rcx
add    %r9,%rax
je     1231 <ph_sinit+0x131>
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rdi,%rcx,4)
movq   $0x0,(%rsi,%rcx,8)
movq   $0x0,(%rdx,%rcx,8)
movl   $0x0,0x4(%rdi,%rcx,4)
movq   $0x0,0x8(%rsi,%rcx,8)
movq   $0x0,0x8(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1160 <ph_sinit+0x60>
jmp    1231 <ph_sinit+0x131>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     1232 <ph_sinit+0x132>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
xor    %eax,%eax
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movups %xmm0,(%rdi,%rax,4)
movups %xmm0,(%rsi,%rax,8)
movups %xmm0,0x10(%rsi,%rax,8)
movups %xmm0,(%rdx,%rax,8)
movups %xmm0,0x10(%rdx,%rax,8)
movups %xmm0,0x10(%rdi,%rax,4)
movups %xmm0,0x20(%rsi,%rax,8)
movups %xmm0,0x30(%rsi,%rax,8)
movups %xmm0,0x20(%rdx,%rax,8)
movups %xmm0,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r10
jne    11d0 <ph_sinit+0xd0>
test   $0x1,%r8b
je     1228 <ph_sinit+0x128>
xorps  %xmm0,%xmm0
movups %xmm0,(%rdi,%rax,4)
movups %xmm0,(%rsi,%rax,8)
movups %xmm0,0x10(%rsi,%rax,8)
movups %xmm0,(%rdx,%rax,8)
movups %xmm0,0x10(%rdx,%rax,8)
cmp    %r9,%rcx
jne    1128 <ph_sinit+0x28>
ret
xor    %eax,%eax
test   $0x1,%r8b
jne    120f <ph_sinit+0x10f>
jmp    1228 <ph_sinit+0x128>

LLVM IR (-O0):
define void @ph_sinit(i32* %0, i8*** %1, i8*** %2, i32 %3) {
%5 = alloca i32*
%6 = alloca i8***
%7 = alloca i8***
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %5
store i8*** %1, i8**** %6
store i8*** %2, i8**** %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %10
10: ; preds = %27, %4
%11 = load i32, i32* %9
%12 = load i32, i32* %8
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %30
14: ; preds = %10
%15 = load i32*, i32** %5
%16 = load i32, i32* %9
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i32, i32* %15, i64 %17
store i32 0, i32* %18
%19 = load i8***, i8**** %6
%20 = load i32, i32* %9
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8**, i8*** %19, i64 %21
store i8** null, i8*** %22
%23 = load i8***, i8**** %7
%24 = load i32, i32* %9
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8**, i8*** %23, i64 %25
store i8** null, i8*** %26
br label %27
27: ; preds = %14
%28 = load i32, i32* %9
%29 = add nsw i32 %28, 1
store i32 %29, i32* %9
br label %10
30: ; preds = %10
ret void
}

LLVM IR (-O2):
define void @ph_sinit(i32* nocapture writeonly %0, i8*** nocapture writeonly %1, i8*** nocapture writeonly %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %98
6: ; preds = %4
%7 = zext i32 %3 to i64
%8 = icmp ult i32 %3, 4
br i1 %8, label %73, label %9
9: ; preds = %6
%10 = getelementptr i8**, i8*** %1, i64 %7
%11 = getelementptr i8**, i8*** %2, i64 %7
%12 = icmp ugt i8*** %11, %1
%13 = icmp ugt i8*** %10, %2
%14 = and i1 %12, %13
br i1 %14, label %73, label %15
15: ; preds = %9
%16 = and i64 %7, 4294967292
%17 = add nsw i64 %16, -4
%18 = lshr exact i64 %17, 2
%19 = add nuw nsw i64 %18, 1
%20 = and i64 %19, 1
%21 = icmp eq i64 %17, 0
br i1 %21, label %55, label %22
22: ; preds = %15
%23 = and i64 %19, 9223372036854775806
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %52, %24 ]
%26 = phi i64 [ 0, %22 ], [ %53, %24 ]
%27 = getelementptr inbounds i32, i32* %0, i64 %25
%28 = bitcast i32* %27 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %28
%29 = getelementptr inbounds i32, i32* %27, i64 2
%30 = bitcast i32* %29 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %30
%31 = getelementptr inbounds i8**, i8*** %1, i64 %25
%32 = bitcast i8*** %31 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %32
%33 = getelementptr inbounds i8**, i8*** %31, i64 2
%34 = bitcast i8*** %33 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %34
%35 = getelementptr inbounds i8**, i8*** %2, i64 %25
%36 = bitcast i8*** %35 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %36
%37 = getelementptr inbounds i8**, i8*** %35, i64 2
%38 = bitcast i8*** %37 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %38
%39 = or i64 %25, 4
%40 = getelementptr inbounds i32, i32* %0, i64 %39
%41 = bitcast i32* %40 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %41
%42 = getelementptr inbounds i32, i32* %40, i64 2
%43 = bitcast i32* %42 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %43
%44 = getelementptr inbounds i8**, i8*** %1, i64 %39
%45 = bitcast i8*** %44 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %45
%46 = getelementptr inbounds i8**, i8*** %44, i64 2
%47 = bitcast i8*** %46 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %47
%48 = getelementptr inbounds i8**, i8*** %2, i64 %39
%49 = bitcast i8*** %48 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %49
%50 = getelementptr inbounds i8**, i8*** %48, i64 2
%51 = bitcast i8*** %50 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %51
%52 = add nuw i64 %25, 8
%53 = add i64 %26, 2
%54 = icmp eq i64 %53, %23
br i1 %54, label %55, label %24
55: ; preds = %24, %15
%56 = phi i64 [ 0, %15 ], [ %52, %24 ]
%57 = icmp eq i64 %20, 0
br i1 %57, label %71, label %58
58: ; preds = %55
%59 = getelementptr inbounds i32, i32* %0, i64 %56
%60 = bitcast i32* %59 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 2
%62 = bitcast i32* %61 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %62
%63 = getelementptr inbounds i8**, i8*** %1, i64 %56
%64 = bitcast i8*** %63 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %64
%65 = getelementptr inbounds i8**, i8*** %63, i64 2
%66 = bitcast i8*** %65 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %66
%67 = getelementptr inbounds i8**, i8*** %2, i64 %56
%68 = bitcast i8*** %67 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %68
%69 = getelementptr inbounds i8**, i8*** %67, i64 2
%70 = bitcast i8*** %69 to <2 x i8**>*
store <2 x i8**> zeroinitializer, <2 x i8**>* %70
br label %71
71: ; preds = %55, %58
%72 = icmp eq i64 %16, %7
br i1 %72, label %98, label %73
73: ; preds = %9, %6, %71
%74 = phi i64 [ 0, %9 ], [ 0, %6 ], [ %16, %71 ]
%75 = xor i64 %74, -1
%76 = and i64 %7, 1
%77 = icmp eq i64 %76, 0
br i1 %77, label %83, label %78
78: ; preds = %73
%79 = getelementptr inbounds i32, i32* %0, i64 %74
store i32 0, i32* %79
%80 = getelementptr inbounds i8**, i8*** %1, i64 %74
store i8** null, i8*** %80
%81 = getelementptr inbounds i8**, i8*** %2, i64 %74
store i8** null, i8*** %81
%82 = or i64 %74, 1
br label %83
83: ; preds = %78, %73
%84 = phi i64 [ %74, %73 ], [ %82, %78 ]
%85 = sub nsw i64 0, %7
%86 = icmp eq i64 %75, %85
br i1 %86, label %98, label %87
87: ; preds = %83, %87
%88 = phi i64 [ %96, %87 ], [ %84, %83 ]
%89 = getelementptr inbounds i32, i32* %0, i64 %88
store i32 0, i32* %89
%90 = getelementptr inbounds i8**, i8*** %1, i64 %88
store i8** null, i8*** %90
%91 = getelementptr inbounds i8**, i8*** %2, i64 %88
store i8** null, i8*** %91
%92 = add nuw nsw i64 %88, 1
%93 = getelementptr inbounds i32, i32* %0, i64 %92
store i32 0, i32* %93
%94 = getelementptr inbounds i8**, i8*** %1, i64 %92
store i8** null, i8*** %94
%95 = getelementptr inbounds i8**, i8*** %2, i64 %92
store i8** null, i8*** %95
%96 = add nuw nsw i64 %88, 2
%97 = icmp eq i64 %96, %7
br i1 %97, label %98, label %87
98: ; preds = %83, %87, %71, %4
ret void
}