#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 ptrdiff_t;
typedef scalar_t__ UChar;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
ptrdiff_t compute_fold_length(UChar *fold_start, ptrdiff_t line_length,
                              ptrdiff_t target_length, int window,
                              int allow_folding_before_semi) {
  assert(target_length > window);
  if (line_length <= target_length + window) {
    return line_length;
  } else {
    int best_category = 0;
    int best_diff = -(window + 1);
    int diff;
    UChar this_char = fold_start[target_length - (window + 1)];
    int is_space =
        ((this_char == ((UChar)0x20)) || (this_char == ((UChar)0x09)));
    int was_space;
    for (diff = -window; diff; diff += 1) {
      int category;
      was_space = is_space;
      this_char = fold_start[target_length + diff];
      is_space = ((this_char == ((UChar)0x20)) || (this_char == ((UChar)0x09)));
      category = (allow_folding_before_semi || (this_char != ((UChar)0x3b)))
                     ? ((was_space * 2) + !is_space)
                     : 0;
      if (category >= best_category) {
        best_diff = diff;
        best_category = category;
      }
    }
    for (; diff <= window; diff += 1) {
      int category;
      was_space = is_space;
      this_char = fold_start[target_length + diff];
      is_space = ((this_char == ((UChar)0x20)) || (this_char == ((UChar)0x09)));
      category = (allow_folding_before_semi || (this_char != ((UChar)0x3b)))
                     ? ((was_space * 2) + !is_space)
                     : 0;
      if (category == 3) {
        best_diff = diff;
        break;
      } else if (category > best_category) {
        best_diff = diff;
        best_category = category;
      } else if ((category == best_category) && (diff <= -best_diff)) {
        best_diff = diff;
        best_category = category;
      }
    }
    if (best_category) {
      return target_length + best_diff;
    } else {
      ptrdiff_t best_length;
      for (best_length = target_length - (window + 1); best_length > 0;
           best_length -= 1) {
        if (fold_start[best_length] != ((UChar)0x3b)) {
          break;
        }
      }
      return best_length;
    }
  }
}


x86 assembly (clang, -O0):
<compute_fold_length>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jg     1158 <compute_fold_length+0x48>
mov    -0x14(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13de <compute_fold_length+0x2ce>
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    $0x1,%al
cmpq   $0x20,-0x38(%rbp)
mov    %al,-0x4d(%rbp)
je     11a1 <compute_fold_length+0x91>
cmpq   $0x9,-0x38(%rbp)
sete   %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     126f <compute_fold_length+0x15f>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    $0x1,%al
cmpq   $0x20,-0x38(%rbp)
mov    %al,-0x4e(%rbp)
je     11f4 <compute_fold_length+0xe4>
cmpq   $0x9,-0x38(%rbp)
sete   %al
mov    %al,-0x4e(%rbp)
mov    -0x4e(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x20(%rbp)
jne    1214 <compute_fold_length+0x104>
cmpq   $0x3b,-0x38(%rbp)
je     1234 <compute_fold_length+0x124>
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
cmpl   $0x0,-0x3c(%rbp)
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
jmp    123e <compute_fold_length+0x12e>
xor    %eax,%eax
mov    %eax,-0x54(%rbp)
jmp    123e <compute_fold_length+0x12e>
mov    -0x54(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     125c <compute_fold_length+0x14c>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1261 <compute_fold_length+0x151>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11b4 <compute_fold_length+0xa4>
jmp    1274 <compute_fold_length+0x164>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     137d <compute_fold_length+0x26d>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    $0x1,%al
cmpq   $0x20,-0x38(%rbp)
mov    %al,-0x55(%rbp)
je     12b6 <compute_fold_length+0x1a6>
cmpq   $0x9,-0x38(%rbp)
sete   %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x20(%rbp)
jne    12d6 <compute_fold_length+0x1c6>
cmpq   $0x3b,-0x38(%rbp)
je     12f6 <compute_fold_length+0x1e6>
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
cmpl   $0x0,-0x3c(%rbp)
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %eax,-0x5c(%rbp)
jmp    1300 <compute_fold_length+0x1f0>
xor    %eax,%eax
mov    %eax,-0x5c(%rbp)
jmp    1300 <compute_fold_length+0x1f0>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x3,-0x48(%rbp)
jne    131b <compute_fold_length+0x20b>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    137d <compute_fold_length+0x26d>
mov    -0x48(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    1338 <compute_fold_length+0x228>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1365 <compute_fold_length+0x255>
mov    -0x48(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1360 <compute_fold_length+0x250>
mov    -0x2c(%rbp),%eax
xor    %ecx,%ecx
sub    -0x28(%rbp),%ecx
cmp    %ecx,%eax
jg     1360 <compute_fold_length+0x250>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1365 <compute_fold_length+0x255>
jmp    136a <compute_fold_length+0x25a>
jmp    136f <compute_fold_length+0x25f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1274 <compute_fold_length+0x164>
cmpl   $0x0,-0x24(%rbp)
je     1395 <compute_fold_length+0x285>
mov    -0x18(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13de <compute_fold_length+0x2ce>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jle    13d8 <compute_fold_length+0x2c8>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpq   $0x3b,(%rax,%rcx,8)
je     13c5 <compute_fold_length+0x2b5>
jmp    13d8 <compute_fold_length+0x2c8>
jmp    13ca <compute_fold_length+0x2ba>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13a3 <compute_fold_length+0x293>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_fold_length>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8d,%r14d
mov    %ecx,%r13d
mov    %edx,%ebx
mov    %esi,%r12d
mov    %rdi,%rbp
xor    %edi,%edi
mov    %edx,%r15d
sub    %ecx,%r15d
setg   %dil
call   1030 <assert@plt>
lea    (%rbx,%r13,1),%eax
cmp    %r12d,%eax
jge    12e4 <compute_fold_length+0x1d4>
mov    %r13d,%r10d
not    %r10d
lea    (%r10,%rbx,1),%r12d
movslq %r12d,%rax
mov    0x0(%rbp,%rax,8),%rax
cmp    $0x20,%rax
sete   %cl
cmp    $0x9,%rax
sete   %dl
or     %cl,%dl
mov    %rbx,0x10(%rsp)
movslq %ebx,%rsi
test   %r13d,%r13d
je     121f <compute_fold_length+0x10f>
mov    %r13d,%eax
neg    %eax
cltq
mov    %rsi,(%rsp)
add    %rsi,%rax
mov    %rbp,0x8(%rsp)
lea    0x0(,%rax,8),%rdi
add    %rbp,%rdi
lea    0x1(%r10),%ebx
xor    %ecx,%ecx
mov    %edx,%r9d
jmp    11e8 <compute_fold_length+0xd8>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x9,%rsi
sete   %r11b
cmp    $0x20,%rsi
sete   %al
movzbl %r9b,%esi
and    $0x1,%esi
xor    %r11b,%al
xor    $0x1,%al
movzbl %al,%eax
lea    (%rax,%rsi,2),%ebp
or     %r8b,%dl
cmp    %ecx,%ebp
cmovae %ebx,%r10d
cmovae %ebp,%ecx
add    $0x8,%rdi
mov    %edx,%r9d
inc    %ebx
je     120c <compute_fold_length+0xfc>
mov    (%rdi),%rsi
cmp    $0x20,%rsi
sete   %dl
cmp    $0x9,%rsi
sete   %r8b
test   %r14d,%r14d
jne    11b0 <compute_fold_length+0xa0>
mov    $0x0,%ebp
cmp    $0x3b,%rsi
je     11d1 <compute_fold_length+0xc1>
jmp    11b0 <compute_fold_length+0xa0>
test   %r13d,%r13d
mov    0x8(%rsp),%rbp
mov    (%rsp),%rsi
jns    1227 <compute_fold_length+0x117>
jmp    12d8 <compute_fold_length+0x1c8>
mov    $0xffffffff,%r10d
xor    %ecx,%ecx
add    $0x1,%r13d
lea    0x0(,%rsi,8),%r8
add    %rbp,%r8
xor    %esi,%esi
mov    %ecx,%edi
jmp    1254 <compute_fold_length+0x144>
nopl   0x0(%rax)
mov    %edi,%ecx
or     %r9b,%bl
add    $0x1,%rsi
mov    %ebx,%edx
cmp    %rsi,%r13
je     12d8 <compute_fold_length+0x1c8>
mov    (%r8,%rsi,8),%rax
cmp    $0x20,%rax
sete   %bl
cmp    $0x9,%rax
sete   %r9b
test   %r14d,%r14d
jne    1277 <compute_fold_length+0x167>
mov    $0x0,%ecx
cmp    $0x3b,%rax
je     129a <compute_fold_length+0x18a>
cmp    $0x9,%rax
sete   %cl
cmp    $0x20,%rax
sete   %al
movzbl %dl,%edx
and    $0x1,%edx
xor    %cl,%al
xor    $0x1,%al
movzbl %al,%eax
lea    (%rax,%rdx,2),%ecx
cmp    $0x3,%ecx
je     12d3 <compute_fold_length+0x1c3>
cmp    %edi,%ecx
jle    12b0 <compute_fold_length+0x1a0>
mov    %esi,%r10d
mov    %ecx,%edi
jmp    1242 <compute_fold_length+0x132>
cs nopw 0x0(%rax,%rax,1)
nop
setne  %al
mov    %r10d,%edx
neg    %edx
movslq %edx,%rdx
cmp    %rdx,%rsi
setg   %dl
or     %al,%dl
jne    1240 <compute_fold_length+0x130>
mov    %esi,%r10d
mov    %ecx,%edi
jmp    1240 <compute_fold_length+0x130>
mov    %edi,%ecx
mov    %esi,%r10d
test   %ecx,%ecx
je     12f6 <compute_fold_length+0x1e6>
add    0x10(%rsp),%r10d
mov    %r10d,%r12d
mov    %r12d,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r12d,%r12d
jle    12e4 <compute_fold_length+0x1d4>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%r15),%r12d
cmpq   $0x3b,0x0(%rbp,%r12,8)
jne    12e4 <compute_fold_length+0x1d4>
add    $0xffffffff,%r15d
cmp    $0x1,%r15d
jg     1300 <compute_fold_length+0x1f0>
xor    %r12d,%r12d
jmp    12e4 <compute_fold_length+0x1d4>

LLVM IR (-O0):
define i32 @compute_fold_length(i64* %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i32
%7 = alloca i64*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i64
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
store i64* %0, i64** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
%21 = load i32, i32* %9
%22 = load i32, i32* %10
%23 = icmp sgt i32 %21, %22
%24 = zext i1 %23 to i32
%25 = call i32 @assert(i32 %24)
%26 = load i32, i32* %8
%27 = load i32, i32* %9
%28 = load i32, i32* %10
%29 = add nsw i32 %27, %28
%30 = icmp sle i32 %26, %29
br i1 %30, label %31, label %33
31: ; preds = %5
%32 = load i32, i32* %8
store i32 %32, i32* %6
br label %197
33: ; preds = %5
store i32 0, i32* %12
%34 = load i32, i32* %10
%35 = add nsw i32 %34, 1
%36 = sub nsw i32 0, %35
store i32 %36, i32* %13
%37 = load i64*, i64** %7
%38 = load i32, i32* %9
%39 = load i32, i32* %10
%40 = add nsw i32 %39, 1
%41 = sub nsw i32 %38, %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i64, i64* %37, i64 %42
%44 = load i64, i64* %43
store i64 %44, i64* %15
%45 = load i64, i64* %15
%46 = icmp eq i64 %45, 32
br i1 %46, label %50, label %47
47: ; preds = %33
%48 = load i64, i64* %15
%49 = icmp eq i64 %48, 9
br label %50
50: ; preds = %47, %33
%51 = phi i1 [ true, %33 ], [ %49, %47 ]
%52 = zext i1 %51 to i32
store i32 %52, i32* %16
%53 = load i32, i32* %10
%54 = sub nsw i32 0, %53
store i32 %54, i32* %14
br label %55
55: ; preds = %98, %50
%56 = load i32, i32* %14
%57 = icmp ne i32 %56, 0
br i1 %57, label %58, label %101
58: ; preds = %55
%59 = load i32, i32* %16
store i32 %59, i32* %17
%60 = load i64*, i64** %7
%61 = load i32, i32* %9
%62 = load i32, i32* %14
%63 = add nsw i32 %61, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i64, i64* %60, i64 %64
%66 = load i64, i64* %65
store i64 %66, i64* %15
%67 = load i64, i64* %15
%68 = icmp eq i64 %67, 32
br i1 %68, label %72, label %69
69: ; preds = %58
%70 = load i64, i64* %15
%71 = icmp eq i64 %70, 9
br label %72
72: ; preds = %69, %58
%73 = phi i1 [ true, %58 ], [ %71, %69 ]
%74 = zext i1 %73 to i32
store i32 %74, i32* %16
%75 = load i32, i32* %11
%76 = icmp ne i32 %75, 0
br i1 %76, label %80, label %77
77: ; preds = %72
%78 = load i64, i64* %15
%79 = icmp ne i64 %78, 59
br i1 %79, label %80, label %88
80: ; preds = %77, %72
%81 = load i32, i32* %17
%82 = mul nsw i32 %81, 2
%83 = load i32, i32* %16
%84 = icmp ne i32 %83, 0
%85 = xor i1 %84, true
%86 = zext i1 %85 to i32
%87 = add nsw i32 %82, %86
br label %89
88: ; preds = %77
br label %89
89: ; preds = %88, %80
%90 = phi i32 [ %87, %80 ], [ 0, %88 ]
store i32 %90, i32* %18
%91 = load i32, i32* %18
%92 = load i32, i32* %12
%93 = icmp sge i32 %91, %92
br i1 %93, label %94, label %97
94: ; preds = %89
%95 = load i32, i32* %14
store i32 %95, i32* %13
%96 = load i32, i32* %18
store i32 %96, i32* %12
br label %97
97: ; preds = %94, %89
br label %98
98: ; preds = %97
%99 = load i32, i32* %14
%100 = add nsw i32 %99, 1
store i32 %100, i32* %14
br label %55
101: ; preds = %55
br label %102
102: ; preds = %165, %101
%103 = load i32, i32* %14
%104 = load i32, i32* %10
%105 = icmp sle i32 %103, %104
br i1 %105, label %106, label %168
106: ; preds = %102
%107 = load i32, i32* %16
store i32 %107, i32* %17
%108 = load i64*, i64** %7
%109 = load i32, i32* %9
%110 = load i32, i32* %14
%111 = add nsw i32 %109, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i64, i64* %108, i64 %112
%114 = load i64, i64* %113
store i64 %114, i64* %15
%115 = load i64, i64* %15
%116 = icmp eq i64 %115, 32
br i1 %116, label %120, label %117
117: ; preds = %106
%118 = load i64, i64* %15
%119 = icmp eq i64 %118, 9
br label %120
120: ; preds = %117, %106
%121 = phi i1 [ true, %106 ], [ %119, %117 ]
%122 = zext i1 %121 to i32
store i32 %122, i32* %16
%123 = load i32, i32* %11
%124 = icmp ne i32 %123, 0
br i1 %124, label %128, label %125
125: ; preds = %120
%126 = load i64, i64* %15
%127 = icmp ne i64 %126, 59
br i1 %127, label %128, label %136
128: ; preds = %125, %120
%129 = load i32, i32* %17
%130 = mul nsw i32 %129, 2
%131 = load i32, i32* %16
%132 = icmp ne i32 %131, 0
%133 = xor i1 %132, true
%134 = zext i1 %133 to i32
%135 = add nsw i32 %130, %134
br label %137
136: ; preds = %125
br label %137
137: ; preds = %136, %128
%138 = phi i32 [ %135, %128 ], [ 0, %136 ]
store i32 %138, i32* %19
%139 = load i32, i32* %19
%140 = icmp eq i32 %139, 3
br i1 %140, label %141, label %143
141: ; preds = %137
%142 = load i32, i32* %14
store i32 %142, i32* %13
br label %168
143: ; preds = %137
%144 = load i32, i32* %19
%145 = load i32, i32* %12
%146 = icmp sgt i32 %144, %145
br i1 %146, label %147, label %150
147: ; preds = %143
%148 = load i32, i32* %14
store i32 %148, i32* %13
%149 = load i32, i32* %19
store i32 %149, i32* %12
br label %163
150: ; preds = %143
%151 = load i32, i32* %19
%152 = load i32, i32* %12
%153 = icmp eq i32 %151, %152
br i1 %153, label %154, label %162
154: ; preds = %150
%155 = load i32, i32* %14
%156 = load i32, i32* %13
%157 = sub nsw i32 0, %156
%158 = icmp sle i32 %155, %157
br i1 %158, label %159, label %162
159: ; preds = %154
%160 = load i32, i32* %14
store i32 %160, i32* %13
%161 = load i32, i32* %19
store i32 %161, i32* %12
br label %162
162: ; preds = %159, %154, %150
br label %163
163: ; preds = %162, %147
br label %164
164: ; preds = %163
br label %165
165: ; preds = %164
%166 = load i32, i32* %14
%167 = add nsw i32 %166, 1
store i32 %167, i32* %14
br label %102
168: ; preds = %141, %102
%169 = load i32, i32* %12
%170 = icmp ne i32 %169, 0
br i1 %170, label %171, label %175
171: ; preds = %168
%172 = load i32, i32* %9
%173 = load i32, i32* %13
%174 = add nsw i32 %172, %173
store i32 %174, i32* %6
br label %197
175: ; preds = %168
%176 = load i32, i32* %9
%177 = load i32, i32* %10
%178 = add nsw i32 %177, 1
%179 = sub nsw i32 %176, %178
store i32 %179, i32* %20
br label %180
180: ; preds = %192, %175
%181 = load i32, i32* %20
%182 = icmp sgt i32 %181, 0
br i1 %182, label %183, label %195
183: ; preds = %180
%184 = load i64*, i64** %7
%185 = load i32, i32* %20
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i64, i64* %184, i64 %186
%188 = load i64, i64* %187
%189 = icmp ne i64 %188, 59
br i1 %189, label %190, label %191
190: ; preds = %183
br label %195
191: ; preds = %183
br label %192
192: ; preds = %191
%193 = load i32, i32* %20
%194 = sub nsw i32 %193, 1
store i32 %194, i32* %20
br label %180
195: ; preds = %190, %180
%196 = load i32, i32* %20
store i32 %196, i32* %6
br label %197
197: ; preds = %195, %171, %31
%198 = load i32, i32* %6
ret i32 %198
}

LLVM IR (-O2):
define i32 @compute_fold_length(i64* nocapture %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp sgt i32 %2, %3
%7 = zext i1 %6 to i32
%8 = tail call i32 @assert(i32 %7)
%9 = add nsw i32 %3, %2
%10 = icmp slt i32 %9, %1
br i1 %10, label %11, label %120
11: ; preds = %5
%12 = xor i32 %3, -1
%13 = add i32 %12, %2
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i64, i64* %0, i64 %14
%16 = load i64, i64* %15
%17 = icmp eq i64 %16, 32
%18 = icmp eq i64 %16, 9
%19 = or i1 %17, %18
%20 = icmp eq i32 %3, 0
br i1 %20, label %28, label %21
21: ; preds = %11
%22 = sub i32 0, %3
%23 = icmp ne i32 %4, 0
%24 = sext i32 %22 to i64
%25 = sext i32 %2 to i64
br label %36
26: ; preds = %55
%27 = icmp slt i32 %3, 0
br i1 %27, label %103, label %28
28: ; preds = %11, %26
%29 = phi i32 [ %60, %26 ], [ 0, %11 ]
%30 = phi i1 [ %46, %26 ], [ %19, %11 ]
%31 = phi i32 [ %59, %26 ], [ -1, %11 ]
%32 = icmp ne i32 %4, 0
%33 = sext i32 %2 to i64
%34 = add nuw i32 %3, 1
%35 = zext i32 %34 to i64
br label %64
36: ; preds = %21, %55
%37 = phi i64 [ %24, %21 ], [ %61, %55 ]
%38 = phi i32 [ 0, %21 ], [ %60, %55 ]
%39 = phi i1 [ %19, %21 ], [ %46, %55 ]
%40 = phi i32 [ %12, %21 ], [ %59, %55 ]
%41 = add nsw i64 %37, %25
%42 = getelementptr inbounds i64, i64* %0, i64 %41
%43 = load i64, i64* %42
%44 = icmp eq i64 %43, 32
%45 = icmp eq i64 %43, 9
%46 = or i1 %44, %45
%47 = icmp ne i64 %43, 59
%48 = select i1 %23, i1 true, i1 %47
br i1 %48, label %49, label %55
49: ; preds = %36
%50 = select i1 %39, i32 2, i32 0
%51 = xor i1 %45, %44
%52 = xor i1 %51, true
%53 = zext i1 %52 to i32
%54 = or i32 %50, %53
br label %55
55: ; preds = %36, %49
%56 = phi i32 [ %54, %49 ], [ 0, %36 ]
%57 = icmp ult i32 %56, %38
%58 = trunc i64 %37 to i32
%59 = select i1 %57, i32 %40, i32 %58
%60 = select i1 %57, i32 %38, i32 %56
%61 = add nsw i64 %37, 1
%62 = trunc i64 %61 to i32
%63 = icmp eq i32 %62, 0
br i1 %63, label %26, label %36
64: ; preds = %28, %96
%65 = phi i64 [ 0, %28 ], [ %99, %96 ]
%66 = phi i32 [ %29, %28 ], [ %98, %96 ]
%67 = phi i1 [ %30, %28 ], [ %74, %96 ]
%68 = phi i32 [ %31, %28 ], [ %97, %96 ]
%69 = add nsw i64 %65, %33
%70 = getelementptr inbounds i64, i64* %0, i64 %69
%71 = load i64, i64* %70
%72 = icmp eq i64 %71, 32
%73 = icmp eq i64 %71, 9
%74 = or i1 %72, %73
%75 = icmp ne i64 %71, 59
%76 = select i1 %32, i1 true, i1 %75
br i1 %76, label %77, label %84
77: ; preds = %64
%78 = select i1 %67, i32 2, i32 0
%79 = xor i1 %73, %72
%80 = xor i1 %79, true
%81 = zext i1 %80 to i32
%82 = or i32 %78, %81
%83 = icmp eq i32 %82, 3
br i1 %83, label %101, label %84
84: ; preds = %64, %77
%85 = phi i32 [ %82, %77 ], [ 0, %64 ]
%86 = trunc i64 %65 to i32
%87 = icmp sgt i32 %85, %66
br i1 %87, label %96, label %88
88: ; preds = %84
%89 = icmp ne i32 %85, %66
%90 = sub nsw i32 0, %68
%91 = sext i32 %90 to i64
%92 = icmp sgt i64 %65, %91
%93 = select i1 %89, i1 true, i1 %92
%94 = select i1 %93, i32 %68, i32 %86
%95 = select i1 %93, i32 %66, i32 %85
br label %96
96: ; preds = %84, %88
%97 = phi i32 [ %94, %88 ], [ %86, %84 ]
%98 = phi i32 [ %95, %88 ], [ %85, %84 ]
%99 = add nuw nsw i64 %65, 1
%100 = icmp eq i64 %99, %35
br i1 %100, label %103, label %64
101: ; preds = %77
%102 = trunc i64 %65 to i32
br label %103
103: ; preds = %96, %101, %26
%104 = phi i32 [ %60, %26 ], [ %66, %101 ], [ %98, %96 ]
%105 = phi i32 [ %59, %26 ], [ %102, %101 ], [ %97, %96 ]
%106 = icmp eq i32 %104, 0
br i1 %106, label %107, label %109
107: ; preds = %103
%108 = icmp sgt i32 %13, 0
br i1 %108, label %111, label %120
109: ; preds = %103
%110 = add nsw i32 %105, %2
br label %120
111: ; preds = %107, %117
%112 = phi i32 [ %118, %117 ], [ %13, %107 ]
%113 = zext i32 %112 to i64
%114 = getelementptr inbounds i64, i64* %0, i64 %113
%115 = load i64, i64* %114
%116 = icmp eq i64 %115, 59
br i1 %116, label %117, label %120
117: ; preds = %111
%118 = add nsw i32 %112, -1
%119 = icmp sgt i32 %112, 1
br i1 %119, label %111, label %120
120: ; preds = %117, %111, %107, %109, %5
%121 = phi i32 [ %1, %5 ], [ %110, %109 ], [ %13, %107 ], [ 0, %117 ], [ %112, %111 ]
ret i32 %121
}