#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 scalar_t__ bp;

/* Variables and functions */
void *coalesce(void *bp) {
  size_t prev_alloc = (((*(unsigned int *)(((char *)(bp)-4))) >> 1) & 0x1);
  size_t next_alloc =
      ((*(unsigned int *)((
           (char *)(((char *)(bp) +
                     ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7))) -
           4))) &
       0x1);
  size_t size = ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7);
  if (prev_alloc && next_alloc) {
    return bp;
  } else if (prev_alloc && !next_alloc) {
    size += ((*(unsigned int *)((
                 (char *)(((char *)(bp) +
                           ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7))) -
                 4))) &
             ~0x7);
    (*(unsigned int *)(((char *)(bp)-4)) = (((size) | (0) | (1 << 1))));
    (*(unsigned int *)(((char *)(bp) +
                        ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7) - 8)) =
         (((size) | (0) | (1 << 1))));
  } else if (!prev_alloc && next_alloc) {
    size += ((*(unsigned int *)((
                 (char *)(((char *)(bp) -
                           ((*(unsigned int *)(((char *)(bp)-8))) & ~0x7))) -
                 4))) &
             ~0x7);
    (*(unsigned int *)(((char *)(bp) +
                        ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7) - 8)) =
         (((size) | (0) | (1 << 1))));
    (*(unsigned int *)((
         (char *)(((char *)(bp) -
                   ((*(unsigned int *)(((char *)(bp)-8))) & ~0x7))) -
         4)) = (((size) | (0) | (1 << 1))));
    bp = ((char *)(bp) - ((*(unsigned int *)(((char *)(bp)-8))) & ~0x7));
  } else {
    size +=
        ((*(unsigned int *)((
             (char *)(((char *)(bp) -
                       ((*(unsigned int *)(((char *)(bp)-8))) & ~0x7))) -
             4))) &
         ~0x7) +
        ((*(unsigned int *)((
             (char *)(((char *)(bp) +
                       ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7))) +
             ((*(unsigned int *)((
                  (char *)(((char *)(bp) +
                            ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7))) -
                  4))) &
              ~0x7) -
             8))) &
         ~0x7);
    (*(unsigned int *)((
         (char *)(((char *)(bp) -
                   ((*(unsigned int *)(((char *)(bp)-8))) & ~0x7))) -
         4)) = (((size) | (0) | (1 << 1))));
    (*(unsigned int *)((
         (char *)(((char *)(bp) +
                   ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7))) +
         ((*(unsigned int *)((
              (char *)(((char *)(bp) +
                        ((*(unsigned int *)(((char *)(bp)-4))) & ~0x7))) -
              4))) &
          ~0x7) -
         8)) = (((size) | (0) | (1 << 1))));
    bp = ((char *)(bp) - ((*(unsigned int *)(((char *)(bp)-8))) & ~0x7));
  }
  return bp;
}


x86 assembly (clang, -O0):
<coalesce>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rax),%eax
shr    $0x1,%eax
and    $0x1,%eax
mov    %eax,%eax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x4(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    -0x4(%rax,%rcx,1),%eax
and    $0x1,%eax
mov    %eax,%eax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x4(%rax),%eax
and    $0xfffffff8,%eax
mov    %eax,%eax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     116b <coalesce+0x6b>
cmpq   $0x0,-0x20(%rbp)
je     116b <coalesce+0x6b>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    137e <coalesce+0x27e>
cmpq   $0x0,-0x18(%rbp)
je     11de <coalesce+0xde>
cmpq   $0x0,-0x20(%rbp)
jne    11de <coalesce+0xde>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x4(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    -0x4(%rax,%rcx,1),%eax
and    $0xfffffff8,%eax
mov    %eax,%eax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
or     $0x0,%rax
or     $0x2,%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,-0x4(%rax)
mov    -0x28(%rbp),%rax
or     $0x0,%rax
or     $0x2,%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x4(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %edx,-0x8(%rax,%rcx,1)
jmp    1371 <coalesce+0x271>
cmpq   $0x0,-0x18(%rbp)
jne    128a <coalesce+0x18a>
cmpq   $0x0,-0x20(%rbp)
je     128a <coalesce+0x18a>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x8(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    -0x4(%rax,%rcx,1),%eax
and    $0xfffffff8,%eax
mov    %eax,%eax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
or     $0x0,%rax
or     $0x2,%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x4(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %edx,-0x8(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
or     $0x0,%rax
or     $0x2,%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x8(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %ecx,%esi
xor    %ecx,%ecx
sub    %rsi,%rcx
mov    %edx,-0x4(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x8(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    136c <coalesce+0x26c>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x8(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    -0x4(%rax,%rcx,1),%eax
and    $0xfffffff8,%eax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    -0x4(%rdx),%edx
and    $0xfffffff8,%edx
mov    %edx,%edx
add    %rdx,%rcx
mov    -0x10(%rbp),%rdx
mov    -0x10(%rbp),%rsi
mov    -0x4(%rsi),%esi
and    $0xfffffff8,%esi
mov    %esi,%esi
mov    -0x4(%rdx,%rsi,1),%edx
and    $0xfffffff8,%edx
mov    %edx,%edx
mov    -0x8(%rcx,%rdx,1),%ecx
and    $0xfffffff8,%ecx
add    %ecx,%eax
mov    %eax,%eax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
or     $0x0,%rax
or     $0x2,%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x8(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %ecx,%esi
xor    %ecx,%ecx
sub    %rsi,%rcx
mov    %edx,-0x4(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
or     $0x0,%rax
or     $0x2,%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x4(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rsi
mov    -0x4(%rsi),%esi
and    $0xfffffff8,%esi
mov    %esi,%esi
mov    -0x4(%rcx,%rsi,1),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %edx,-0x8(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x8(%rcx),%ecx
and    $0xfffffff8,%ecx
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    1371 <coalesce+0x271>
jmp    1376 <coalesce+0x276>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<coalesce>:
mov    %rdi,%rax
mov    -0x4(%rdi),%esi
mov    %esi,%ecx
and    $0xfffffff8,%ecx
mov    -0x4(%rdi,%rcx,1),%edx
bt     $0x1,%esi
jae    111d <coalesce+0x1d>
mov    %edx,%edi
and    $0x1,%edi
je     111d <coalesce+0x1d>
ret
shr    %esi
test   $0x1,%sil
je     113e <coalesce+0x3e>
mov    %edx,%edi
and    $0x1,%edi
jne    113e <coalesce+0x3e>
and    $0xfffffff8,%edx
add    %ecx,%edx
mov    %edx,%ecx
or     $0x2,%ecx
mov    %ecx,-0x4(%rax)
mov    %ecx,-0x8(%rax,%rdx,1)
ret
mov    %rcx,%r9
add    %rax,%r9
mov    -0x8(%rax),%r8d
and    $0xfffffff8,%r8d
mov    %rax,%rdi
sub    %r8,%rdi
mov    -0x4(%rdi),%edi
and    $0xfffffff8,%edi
test   $0x1,%sil
jne    117d <coalesce+0x7d>
mov    %edx,%esi
and    $0x1,%esi
je     117d <coalesce+0x7d>
add    %ecx,%edi
or     $0x2,%edi
mov    %edi,-0x8(%r9)
mov    -0x8(%rax),%ecx
and    $0xfffffff8,%ecx
neg    %rcx
mov    %edi,-0x4(%rax,%rcx,1)
jmp    11ac <coalesce+0xac>
neg    %r8
and    $0xfffffff8,%edx
mov    -0x8(%r9,%rdx,1),%edx
and    $0xfffffff8,%edx
or     $0x2,%ecx
add    %edi,%ecx
add    %edx,%ecx
mov    %ecx,-0x4(%rax,%r8,1)
mov    -0x4(%rax),%edx
and    $0xfffffff8,%edx
lea    (%rax,%rdx,1),%rsi
mov    -0x4(%rax,%rdx,1),%edx
and    $0xfffffff8,%edx
mov    %ecx,-0x8(%rdx,%rsi,1)
mov    -0x8(%rax),%ecx
and    $0xfffffff8,%ecx
sub    %rcx,%rax
ret

LLVM IR (-O0):
define i8* @coalesce(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
store i8* %0, i8** %3
%7 = load i8*, i8** %3
%8 = getelementptr inbounds i8, i8* %7, i64 -4
%9 = bitcast i8* %8 to i32*
%10 = load i32, i32* %9
%11 = lshr i32 %10, 1
%12 = and i32 %11, 1
%13 = zext i32 %12 to i64
store i64 %13, i64* %4
%14 = load i8*, i8** %3
%15 = load i8*, i8** %3
%16 = getelementptr inbounds i8, i8* %15, i64 -4
%17 = bitcast i8* %16 to i32*
%18 = load i32, i32* %17
%19 = and i32 %18, -8
%20 = zext i32 %19 to i64
%21 = getelementptr inbounds i8, i8* %14, i64 %20
%22 = getelementptr inbounds i8, i8* %21, i64 -4
%23 = bitcast i8* %22 to i32*
%24 = load i32, i32* %23
%25 = and i32 %24, 1
%26 = zext i32 %25 to i64
store i64 %26, i64* %5
%27 = load i8*, i8** %3
%28 = getelementptr inbounds i8, i8* %27, i64 -4
%29 = bitcast i8* %28 to i32*
%30 = load i32, i32* %29
%31 = and i32 %30, -8
%32 = zext i32 %31 to i64
store i64 %32, i64* %6
%33 = load i64, i64* %4
%34 = icmp ne i64 %33, 0
br i1 %34, label %35, label %40
35: ; preds = %1
%36 = load i64, i64* %5
%37 = icmp ne i64 %36, 0
br i1 %37, label %38, label %40
38: ; preds = %35
%39 = load i8*, i8** %3
store i8* %39, i8** %2
br label %244
40: ; preds = %35, %1
%41 = load i64, i64* %4
%42 = icmp ne i64 %41, 0
br i1 %42, label %43, label %83
43: ; preds = %40
%44 = load i64, i64* %5
%45 = icmp ne i64 %44, 0
br i1 %45, label %83, label %46
46: ; preds = %43
%47 = load i8*, i8** %3
%48 = load i8*, i8** %3
%49 = getelementptr inbounds i8, i8* %48, i64 -4
%50 = bitcast i8* %49 to i32*
%51 = load i32, i32* %50
%52 = and i32 %51, -8
%53 = zext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %47, i64 %53
%55 = getelementptr inbounds i8, i8* %54, i64 -4
%56 = bitcast i8* %55 to i32*
%57 = load i32, i32* %56
%58 = and i32 %57, -8
%59 = zext i32 %58 to i64
%60 = load i64, i64* %6
%61 = add i64 %60, %59
store i64 %61, i64* %6
%62 = load i64, i64* %6
%63 = or i64 %62, 0
%64 = or i64 %63, 2
%65 = trunc i64 %64 to i32
%66 = load i8*, i8** %3
%67 = getelementptr inbounds i8, i8* %66, i64 -4
%68 = bitcast i8* %67 to i32*
store i32 %65, i32* %68
%69 = load i64, i64* %6
%70 = or i64 %69, 0
%71 = or i64 %70, 2
%72 = trunc i64 %71 to i32
%73 = load i8*, i8** %3
%74 = load i8*, i8** %3
%75 = getelementptr inbounds i8, i8* %74, i64 -4
%76 = bitcast i8* %75 to i32*
%77 = load i32, i32* %76
%78 = and i32 %77, -8
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds i8, i8* %73, i64 %79
%81 = getelementptr inbounds i8, i8* %80, i64 -8
%82 = bitcast i8* %81 to i32*
store i32 %72, i32* %82
br label %241
83: ; preds = %43, %40
%84 = load i64, i64* %4
%85 = icmp ne i64 %84, 0
br i1 %85, label %144, label %86
86: ; preds = %83
%87 = load i64, i64* %5
%88 = icmp ne i64 %87, 0
br i1 %88, label %89, label %144
89: ; preds = %86
%90 = load i8*, i8** %3
%91 = load i8*, i8** %3
%92 = getelementptr inbounds i8, i8* %91, i64 -8
%93 = bitcast i8* %92 to i32*
%94 = load i32, i32* %93
%95 = and i32 %94, -8
%96 = zext i32 %95 to i64
%97 = sub i64 0, %96
%98 = getelementptr inbounds i8, i8* %90, i64 %97
%99 = getelementptr inbounds i8, i8* %98, i64 -4
%100 = bitcast i8* %99 to i32*
%101 = load i32, i32* %100
%102 = and i32 %101, -8
%103 = zext i32 %102 to i64
%104 = load i64, i64* %6
%105 = add i64 %104, %103
store i64 %105, i64* %6
%106 = load i64, i64* %6
%107 = or i64 %106, 0
%108 = or i64 %107, 2
%109 = trunc i64 %108 to i32
%110 = load i8*, i8** %3
%111 = load i8*, i8** %3
%112 = getelementptr inbounds i8, i8* %111, i64 -4
%113 = bitcast i8* %112 to i32*
%114 = load i32, i32* %113
%115 = and i32 %114, -8
%116 = zext i32 %115 to i64
%117 = getelementptr inbounds i8, i8* %110, i64 %116
%118 = getelementptr inbounds i8, i8* %117, i64 -8
%119 = bitcast i8* %118 to i32*
store i32 %109, i32* %119
%120 = load i64, i64* %6
%121 = or i64 %120, 0
%122 = or i64 %121, 2
%123 = trunc i64 %122 to i32
%124 = load i8*, i8** %3
%125 = load i8*, i8** %3
%126 = getelementptr inbounds i8, i8* %125, i64 -8
%127 = bitcast i8* %126 to i32*
%128 = load i32, i32* %127
%129 = and i32 %128, -8
%130 = zext i32 %129 to i64
%131 = sub i64 0, %130
%132 = getelementptr inbounds i8, i8* %124, i64 %131
%133 = getelementptr inbounds i8, i8* %132, i64 -4
%134 = bitcast i8* %133 to i32*
store i32 %123, i32* %134
%135 = load i8*, i8** %3
%136 = load i8*, i8** %3
%137 = getelementptr inbounds i8, i8* %136, i64 -8
%138 = bitcast i8* %137 to i32*
%139 = load i32, i32* %138
%140 = and i32 %139, -8
%141 = zext i32 %140 to i64
%142 = sub i64 0, %141
%143 = getelementptr inbounds i8, i8* %135, i64 %142
store i8* %143, i8** %3
br label %240
144: ; preds = %86, %83
%145 = load i8*, i8** %3
%146 = load i8*, i8** %3
%147 = getelementptr inbounds i8, i8* %146, i64 -8
%148 = bitcast i8* %147 to i32*
%149 = load i32, i32* %148
%150 = and i32 %149, -8
%151 = zext i32 %150 to i64
%152 = sub i64 0, %151
%153 = getelementptr inbounds i8, i8* %145, i64 %152
%154 = getelementptr inbounds i8, i8* %153, i64 -4
%155 = bitcast i8* %154 to i32*
%156 = load i32, i32* %155
%157 = and i32 %156, -8
%158 = load i8*, i8** %3
%159 = load i8*, i8** %3
%160 = getelementptr inbounds i8, i8* %159, i64 -4
%161 = bitcast i8* %160 to i32*
%162 = load i32, i32* %161
%163 = and i32 %162, -8
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %158, i64 %164
%166 = load i8*, i8** %3
%167 = load i8*, i8** %3
%168 = getelementptr inbounds i8, i8* %167, i64 -4
%169 = bitcast i8* %168 to i32*
%170 = load i32, i32* %169
%171 = and i32 %170, -8
%172 = zext i32 %171 to i64
%173 = getelementptr inbounds i8, i8* %166, i64 %172
%174 = getelementptr inbounds i8, i8* %173, i64 -4
%175 = bitcast i8* %174 to i32*
%176 = load i32, i32* %175
%177 = and i32 %176, -8
%178 = zext i32 %177 to i64
%179 = getelementptr inbounds i8, i8* %165, i64 %178
%180 = getelementptr inbounds i8, i8* %179, i64 -8
%181 = bitcast i8* %180 to i32*
%182 = load i32, i32* %181
%183 = and i32 %182, -8
%184 = add i32 %157, %183
%185 = zext i32 %184 to i64
%186 = load i64, i64* %6
%187 = add i64 %186, %185
store i64 %187, i64* %6
%188 = load i64, i64* %6
%189 = or i64 %188, 0
%190 = or i64 %189, 2
%191 = trunc i64 %190 to i32
%192 = load i8*, i8** %3
%193 = load i8*, i8** %3
%194 = getelementptr inbounds i8, i8* %193, i64 -8
%195 = bitcast i8* %194 to i32*
%196 = load i32, i32* %195
%197 = and i32 %196, -8
%198 = zext i32 %197 to i64
%199 = sub i64 0, %198
%200 = getelementptr inbounds i8, i8* %192, i64 %199
%201 = getelementptr inbounds i8, i8* %200, i64 -4
%202 = bitcast i8* %201 to i32*
store i32 %191, i32* %202
%203 = load i64, i64* %6
%204 = or i64 %203, 0
%205 = or i64 %204, 2
%206 = trunc i64 %205 to i32
%207 = load i8*, i8** %3
%208 = load i8*, i8** %3
%209 = getelementptr inbounds i8, i8* %208, i64 -4
%210 = bitcast i8* %209 to i32*
%211 = load i32, i32* %210
%212 = and i32 %211, -8
%213 = zext i32 %212 to i64
%214 = getelementptr inbounds i8, i8* %207, i64 %213
%215 = load i8*, i8** %3
%216 = load i8*, i8** %3
%217 = getelementptr inbounds i8, i8* %216, i64 -4
%218 = bitcast i8* %217 to i32*
%219 = load i32, i32* %218
%220 = and i32 %219, -8
%221 = zext i32 %220 to i64
%222 = getelementptr inbounds i8, i8* %215, i64 %221
%223 = getelementptr inbounds i8, i8* %222, i64 -4
%224 = bitcast i8* %223 to i32*
%225 = load i32, i32* %224
%226 = and i32 %225, -8
%227 = zext i32 %226 to i64
%228 = getelementptr inbounds i8, i8* %214, i64 %227
%229 = getelementptr inbounds i8, i8* %228, i64 -8
%230 = bitcast i8* %229 to i32*
store i32 %206, i32* %230
%231 = load i8*, i8** %3
%232 = load i8*, i8** %3
%233 = getelementptr inbounds i8, i8* %232, i64 -8
%234 = bitcast i8* %233 to i32*
%235 = load i32, i32* %234
%236 = and i32 %235, -8
%237 = zext i32 %236 to i64
%238 = sub i64 0, %237
%239 = getelementptr inbounds i8, i8* %231, i64 %238
store i8* %239, i8** %3
br label %240
240: ; preds = %144, %89
br label %241
241: ; preds = %240, %46
br label %242
242: ; preds = %241
%243 = load i8*, i8** %3
store i8* %243, i8** %2
br label %244
244: ; preds = %242, %38
%245 = load i8*, i8** %2
ret i8* %245
}

LLVM IR (-O2):
define i8* @coalesce(i8* %0) {
%2 = getelementptr inbounds i8, i8* %0, i64 -4
%3 = bitcast i8* %2 to i32*
%4 = load i32, i32* %3
%5 = lshr i32 %4, 1
%6 = and i32 %5, 1
%7 = and i32 %4, -8
%8 = zext i32 %7 to i64
%9 = getelementptr inbounds i8, i8* %0, i64 %8
%10 = getelementptr inbounds i8, i8* %9, i64 -4
%11 = bitcast i8* %10 to i32*
%12 = load i32, i32* %11
%13 = and i32 %12, 1
%14 = icmp ne i32 %6, 0
%15 = icmp ne i32 %13, 0
%16 = select i1 %14, i1 %15, i1 false
br i1 %16, label %86, label %17
17: ; preds = %1
%18 = icmp eq i32 %6, 0
%19 = select i1 %18, i1 true, i1 %15
br i1 %19, label %28, label %20
20: ; preds = %17
%21 = and i32 %12, -8
%22 = add i32 %21, %7
%23 = or i32 %22, 2
store i32 %23, i32* %3
%24 = zext i32 %22 to i64
%25 = getelementptr inbounds i8, i8* %0, i64 %24
%26 = getelementptr inbounds i8, i8* %25, i64 -8
%27 = bitcast i8* %26 to i32*
store i32 %23, i32* %27
br label %86
28: ; preds = %17
%29 = select i1 %18, i1 %15, i1 false
%30 = getelementptr inbounds i8, i8* %0, i64 -8
%31 = bitcast i8* %30 to i32*
%32 = load i32, i32* %31
%33 = and i32 %32, -8
%34 = zext i32 %33 to i64
%35 = sub nsw i64 0, %34
%36 = getelementptr inbounds i8, i8* %0, i64 %35
%37 = getelementptr inbounds i8, i8* %36, i64 -4
%38 = bitcast i8* %37 to i32*
%39 = load i32, i32* %38
%40 = and i32 %39, -8
br i1 %29, label %41, label %58
41: ; preds = %28
%42 = add i32 %40, %7
%43 = or i32 %42, 2
%44 = getelementptr inbounds i8, i8* %9, i64 -8
%45 = bitcast i8* %44 to i32*
store i32 %43, i32* %45
%46 = load i32, i32* %31
%47 = and i32 %46, -8
%48 = zext i32 %47 to i64
%49 = sub nsw i64 0, %48
%50 = getelementptr inbounds i8, i8* %0, i64 %49
%51 = getelementptr inbounds i8, i8* %50, i64 -4
%52 = bitcast i8* %51 to i32*
store i32 %43, i32* %52
%53 = load i32, i32* %31
%54 = and i32 %53, -8
%55 = zext i32 %54 to i64
%56 = sub nsw i64 0, %55
%57 = getelementptr inbounds i8, i8* %0, i64 %56
br label %86
58: ; preds = %28
%59 = and i32 %12, -8
%60 = zext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %9, i64 %60
%62 = getelementptr inbounds i8, i8* %61, i64 -8
%63 = bitcast i8* %62 to i32*
%64 = load i32, i32* %63
%65 = and i32 %64, -8
%66 = or i32 %7, 2
%67 = add i32 %66, %40
%68 = add i32 %67, %65
store i32 %68, i32* %38
%69 = load i32, i32* %3
%70 = and i32 %69, -8
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %0, i64 %71
%73 = getelementptr inbounds i8, i8* %72, i64 -4
%74 = bitcast i8* %73 to i32*
%75 = load i32, i32* %74
%76 = and i32 %75, -8
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %72, i64 %77
%79 = getelementptr inbounds i8, i8* %78, i64 -8
%80 = bitcast i8* %79 to i32*
store i32 %68, i32* %80
%81 = load i32, i32* %31
%82 = and i32 %81, -8
%83 = zext i32 %82 to i64
%84 = sub nsw i64 0, %83
%85 = getelementptr inbounds i8, i8* %0, i64 %84
br label %86
86: ; preds = %41, %58, %20, %1
%87 = phi i8* [ %0, %1 ], [ %57, %41 ], [ %85, %58 ], [ %0, %20 ]
ret i8* %87
}