#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 */
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int textLCS(const char *zLeft, int nA, const char *zRight, int nB, int *aLCS) {
  const unsigned char *zA = (const unsigned char *)zLeft;
  const unsigned char *zB = (const unsigned char *)zRight;
  int nt;
  int ti[3];
  unsigned int target[3];
  unsigned int probe;
  int iAS, iAE, iBS, iBE;
  int i, j;
  int rc = 0;
  if (nA < 6 || nB < 6)
    return 0;
  memset(aLCS, 0, sizeof(int) * 4);
  ti[0] = i = nB / 2 - 2;
  target[0] = (zB[i] << 24) | (zB[i + 1] << 16) | (zB[i + 2] << 8) | zB[i + 3];
  probe = 0;
  if (nB < 16) {
    nt = 1;
  } else {
    ti[1] = i = nB / 4 - 2;
    target[1] =
        (zB[i] << 24) | (zB[i + 1] << 16) | (zB[i + 2] << 8) | zB[i + 3];
    ti[2] = i = (nB * 3) / 4 - 2;
    target[2] =
        (zB[i] << 24) | (zB[i + 1] << 16) | (zB[i + 2] << 8) | zB[i + 3];
    nt = 3;
  }
  probe = (zA[0] << 16) | (zA[1] << 8) | zA[2];
  for (i = 3; i < nA; i++) {
    probe = (probe << 8) | zA[i];
    for (j = 0; j < nt; j++) {
      if (probe == target[j]) {
        iAS = i - 3;
        iAE = i + 1;
        iBS = ti[j];
        iBE = ti[j] + 4;
        while (iAE < nA && iBE < nB && zA[iAE] == zB[iBE]) {
          iAE++;
          iBE++;
        }
        while (iAS > 0 && iBS > 0 && zA[iAS - 1] == zB[iBS - 1]) {
          iAS--;
          iBS--;
        }
        if (iAE - iAS > aLCS[1] - aLCS[0]) {
          aLCS[0] = iAS;
          aLCS[1] = iAE;
          aLCS[2] = iBS;
          aLCS[3] = iBE;
          rc = 1;
        }
      }
    }
  }
  return rc;
}


x86 assembly (clang, -O0):
<textLCS>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x7c(%rbp)
cmpl   $0x6,-0x14(%rbp)
jl     1158 <textLCS+0x48>
cmpl   $0x6,-0x24(%rbp)
jge    1164 <textLCS+0x54>
movl   $0x0,-0x4(%rbp)
jmp    14bc <textLCS+0x3ac>
mov    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1030 <memset@plt>
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x2,%eax
mov    %eax,-0x74(%rbp)
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    11f6 <textLCS+0xe6>
movl   $0x1,-0x44(%rbp)
jmp    12c8 <textLCS+0x1b8>
mov    -0x24(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
sub    $0x2,%eax
mov    %eax,-0x74(%rbp)
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
imul   $0x3,-0x24(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
sub    $0x2,%eax
mov    %eax,-0x74(%rbp)
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x74(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
mov    -0x74(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
movl   $0x3,-0x44(%rbp)
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
shl    $0x10,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
movl   $0x3,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14b6 <textLCS+0x3a6>
mov    -0x60(%rbp),%eax
shl    $0x8,%eax
mov    -0x38(%rbp),%rcx
movslq -0x74(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14a3 <textLCS+0x393>
mov    -0x60(%rbp),%eax
movslq -0x78(%rbp),%rcx
cmp    -0x5c(%rbp,%rcx,4),%eax
jne    1490 <textLCS+0x380>
mov    -0x74(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x64(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
movslq -0x78(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%eax
mov    %eax,-0x6c(%rbp)
movslq -0x78(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%eax
add    $0x4,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x7d(%rbp)
jge    13a7 <textLCS+0x297>
mov    -0x70(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x7d(%rbp)
jge    13a7 <textLCS+0x297>
mov    -0x38(%rbp),%rax
movslq -0x68(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x7d(%rbp)
mov    -0x7d(%rbp),%al
test   $0x1,%al
jne    13b7 <textLCS+0x2a7>
jmp    13ce <textLCS+0x2be>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1365 <textLCS+0x255>
jmp    13d3 <textLCS+0x2c3>
xor    %eax,%eax
cmpl   $0x0,-0x64(%rbp)
mov    %al,-0x7e(%rbp)
jle    141b <textLCS+0x30b>
xor    %eax,%eax
cmpl   $0x0,-0x6c(%rbp)
mov    %al,-0x7e(%rbp)
jle    141b <textLCS+0x30b>
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x6c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x7e(%rbp)
mov    -0x7e(%rbp),%al
test   $0x1,%al
jne    142b <textLCS+0x31b>
jmp    1442 <textLCS+0x332>
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
mov    -0x6c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
jmp    13d3 <textLCS+0x2c3>
mov    -0x68(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
sub    (%rdx),%ecx
cmp    %ecx,%eax
jle    148b <textLCS+0x37b>
mov    -0x64(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x70(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,0xc(%rax)
movl   $0x1,-0x7c(%rbp)
jmp    1490 <textLCS+0x380>
jmp    1495 <textLCS+0x385>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    131d <textLCS+0x20d>
jmp    14a8 <textLCS+0x398>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12f3 <textLCS+0x1e3>
mov    -0x7c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<textLCS>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8,(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
cmp    $0x6,%esi
jl     154a <textLCS+0x43a>
mov    %ecx,%r14d
cmp    $0x6,%ecx
jl     154a <textLCS+0x43a>
mov    %rdx,%r13
mov    %rdi,%r12
mov    %rsi,0x10(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    (%rsp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1030 <memset@plt>
mov    %r14d,%r15d
mov    %r15,%rax
shr    %rax
lea    -0x2(%rax),%ecx
mov    %ecx,0x4c(%rsp)
movzbl 0x0(%r13,%rcx,1),%ecx
shl    $0x18,%ecx
lea    -0x1(%rax),%edx
movzbl 0x0(%r13,%rdx,1),%edx
shl    $0x10,%edx
or     %ecx,%edx
movzbl 0x0(%r13,%rax,1),%ecx
shl    $0x8,%ecx
or     %edx,%ecx
movzbl 0x1(%r13,%rax,1),%eax
or     %ecx,%eax
mov    %eax,0x40(%rsp)
cmp    $0x10,%r14d
jb     120c <textLCS+0xfc>
mov    %r15,%rax
shr    $0x2,%rax
lea    -0x2(%rax),%ecx
mov    %ecx,0x50(%rsp)
movzbl 0x0(%r13,%rcx,1),%ecx
shl    $0x18,%ecx
lea    -0x1(%rax),%edx
movzbl 0x0(%r13,%rdx,1),%edx
shl    $0x10,%edx
or     %ecx,%edx
movzbl 0x0(%r13,%rax,1),%ecx
shl    $0x8,%ecx
or     %edx,%ecx
movzbl 0x1(%r13,%rax,1),%eax
or     %ecx,%eax
lea    (%r14,%r14,2),%ecx
lea    (%r14,%r14,2),%edx
add    $0x3,%edx
test   %ecx,%ecx
cmovns %ecx,%edx
mov    %eax,0x44(%rsp)
sar    $0x2,%edx
movslq %edx,%rax
lea    -0x2(%rax),%rcx
mov    %ecx,0x54(%rsp)
mov    -0x2(%r13,%rax,1),%eax
bswap  %eax
mov    %eax,0x48(%rsp)
movzbl 0x1(%r12),%eax
shl    $0x8,%eax
movzbl (%r12),%ecx
shl    $0x10,%ecx
or     %eax,%ecx
movzbl 0x2(%r12),%r8d
or     %ecx,%r8d
mov    0x10(%rsp),%rcx
mov    %ecx,%eax
mov    %rax,0x28(%rsp)
lea    -0x3(%rcx),%eax
mov    %rax,0x88(%rsp)
mov    0x40(%rsp),%eax
mov    %eax,0x3c(%rsp)
mov    0x44(%rsp),%eax
mov    %eax,0x38(%rsp)
mov    0x4c(%rsp),%eax
mov    0x50(%rsp),%edx
mov    %rax,0x80(%rsp)
lea    0x4(%rax),%eax
mov    %eax,0x24(%rsp)
cltq
mov    %rax,0x70(%rsp)
mov    %rdx,0x78(%rsp)
lea    0x4(%rdx),%eax
mov    %eax,0x20(%rsp)
cltq
mov    %rax,0x60(%rsp)
mov    0x48(%rsp),%eax
mov    %eax,0x34(%rsp)
mov    0x54(%rsp),%eax
mov    %rax,0x68(%rsp)
add    $0x4,%eax
mov    %eax,0x1c(%rsp)
cltq
mov    %rax,0x58(%rsp)
mov    $0x4,%r9d
mov    $0x3,%r10d
xor    %r11d,%r11d
mov    %r14,0x90(%rsp)
jmp    12d9 <textLCS+0x1c9>
nopl   0x0(%rax,%rax,1)
mov    %ebx,%r8d
add    $0x1,%r9
add    $0x1,%r11
cmp    0x88(%rsp),%r11
je     154a <textLCS+0x43a>
mov    %r8d,%eax
shl    $0x8,%eax
movzbl (%r12,%r10,1),%ebx
or     %eax,%ebx
add    $0x1,%r10
cmp    0x3c(%rsp),%ebx
jne    13a6 <textLCS+0x296>
mov    0x24(%rsp),%eax
mov    %eax,%r8d
mov    %r10,%rdx
cmp    0x28(%rsp),%r10
jae    1340 <textLCS+0x230>
mov    0x24(%rsp),%eax
mov    %eax,%r8d
mov    %r10,%rdx
cmp    %r14d,%eax
jge    1340 <textLCS+0x230>
mov    0x70(%rsp),%r8
mov    %r9,%rdx
nopl   0x0(%rax)
movzbl (%r12,%rdx,1),%eax
cmp    0x0(%r13,%r8,1),%al
jne    1340 <textLCS+0x230>
add    $0x1,%r8
add    $0x1,%rdx
cmp    %ecx,%edx
jge    1340 <textLCS+0x230>
cmp    %r15,%r8
jl     1320 <textLCS+0x210>
nopl   (%rax)
mov    0x80(%rsp),%rbp
mov    %r11,%rdi
nopl   0x0(%rax,%rax,1)
mov    %rdi,%r14
mov    %rbp,%rsi
test   %rdi,%rdi
jle    1374 <textLCS+0x264>
test   %esi,%esi
jle    1374 <textLCS+0x264>
lea    -0x1(%r14),%rdi
movzbl -0x1(%r12,%r14,1),%eax
lea    -0x1(%rsi),%rbp
cmp    -0x1(%r13,%rsi,1),%al
je     1350 <textLCS+0x240>
mov    %edx,%eax
sub    %r14d,%eax
mov    (%rsp),%rdi
mov    0x4(%rdi),%ecx
sub    (%rdi),%ecx
cmp    %ecx,%eax
mov    0x10(%rsp),%rcx
jle    13a6 <textLCS+0x296>
mov    (%rsp),%rax
mov    %r14d,(%rax)
mov    %edx,0x4(%rax)
mov    %esi,0x8(%rax)
mov    %r8d,0xc(%rax)
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    0x90(%rsp),%r14
cmp    $0x10,%r14d
jb     12c0 <textLCS+0x1b0>
mov    %ebx,%r8d
cmp    0x38(%rsp),%ebx
jne    146e <textLCS+0x35e>
mov    0x20(%rsp),%eax
mov    %eax,%edx
mov    %r10,%rsi
cmp    0x28(%rsp),%r10
jae    1410 <textLCS+0x300>
mov    0x20(%rsp),%eax
mov    %eax,%edx
mov    %r10,%rsi
cmp    %r14d,%eax
jge    1410 <textLCS+0x300>
mov    0x60(%rsp),%rdx
mov    %r9,%rsi
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rsi,1),%eax
cmp    0x0(%r13,%rdx,1),%al
jne    1410 <textLCS+0x300>
add    $0x1,%rdx
add    $0x1,%rsi
cmp    %ecx,%esi
jge    1410 <textLCS+0x300>
cmp    %r15,%rdx
jl     13f0 <textLCS+0x2e0>
nopl   (%rax)
mov    0x78(%rsp),%rdi
mov    %r11,%rbp
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rax
mov    %rdi,%rcx
test   %rbp,%rbp
jle    1444 <textLCS+0x334>
test   %ecx,%ecx
jle    1444 <textLCS+0x334>
lea    -0x1(%rax),%rbp
movzbl -0x1(%r12,%rax,1),%ebx
lea    -0x1(%rcx),%rdi
cmp    -0x1(%r13,%rcx,1),%bl
je     1420 <textLCS+0x310>
mov    %esi,%edi
sub    %eax,%edi
mov    (%rsp),%rbx
mov    0x4(%rbx),%ebp
sub    (%rbx),%ebp
cmp    %ebp,%edi
jle    146e <textLCS+0x35e>
mov    (%rsp),%rdi
mov    %eax,(%rdi)
mov    %esi,0x4(%rdi)
mov    %ecx,0x8(%rdi)
mov    %edx,0xc(%rdi)
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
cmp    0x34(%rsp),%r8d
jne    1540 <textLCS+0x430>
mov    0x1c(%rsp),%eax
mov    %eax,%edx
mov    %r10,%rsi
cmp    0x28(%rsp),%r10
jae    14d0 <textLCS+0x3c0>
mov    0x1c(%rsp),%eax
mov    %eax,%edx
mov    %r10,%rsi
cmp    %r14d,%eax
jge    14d0 <textLCS+0x3c0>
mov    0x58(%rsp),%rdx
mov    %r9,%rsi
mov    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r12,%rsi,1),%eax
cmp    0x0(%r13,%rdx,1),%al
jne    14d0 <textLCS+0x3c0>
add    $0x1,%rdx
add    $0x1,%rsi
cmp    %ecx,%esi
jge    14d0 <textLCS+0x3c0>
cmp    %r15,%rdx
jl     14b0 <textLCS+0x3a0>
nopl   (%rax)
mov    0x68(%rsp),%rax
mov    %r11,%rcx
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rbp
mov    %rax,%rdi
test   %rcx,%rcx
jle    1504 <textLCS+0x3f4>
test   %edi,%edi
jle    1504 <textLCS+0x3f4>
lea    -0x1(%rbp),%rcx
movzbl -0x1(%r12,%rbp,1),%ebx
lea    -0x1(%rdi),%rax
cmp    -0x1(%r13,%rdi,1),%bl
je     14e0 <textLCS+0x3d0>
mov    %esi,%eax
sub    %ebp,%eax
mov    (%rsp),%rbx
mov    0x4(%rbx),%ecx
sub    (%rbx),%ecx
cmp    %ecx,%eax
mov    0x10(%rsp),%rcx
jle    12c3 <textLCS+0x1b3>
mov    (%rsp),%rax
mov    %ebp,(%rax)
mov    %esi,0x4(%rax)
mov    %edi,0x8(%rax)
mov    %edx,0xc(%rax)
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
jmp    12c3 <textLCS+0x1b3>
nopl   0x0(%rax)
mov    0x10(%rsp),%rcx
jmp    12c3 <textLCS+0x1b3>
mov    0x8(%rsp),%rax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @textLCS(i8* %0, i32 %1, i8* %2, i32 %3, i32* %4) {
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i32
%15 = alloca [3 x i32]
%16 = alloca [3 x i32]
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
store i8* %0, i8** %7
store i32 %1, i32* %8
store i8* %2, i8** %9
store i32 %3, i32* %10
store i32* %4, i32** %11
%25 = load i8*, i8** %7
store i8* %25, i8** %12
%26 = load i8*, i8** %9
store i8* %26, i8** %13
store i32 0, i32* %24
%27 = load i32, i32* %8
%28 = icmp slt i32 %27, 6
br i1 %28, label %32, label %29
29: ; preds = %5
%30 = load i32, i32* %10
%31 = icmp slt i32 %30, 6
br i1 %31, label %32, label %33
32: ; preds = %29, %5
store i32 0, i32* %6
br label %306
33: ; preds = %29
%34 = load i32*, i32** %11
%35 = call i32 @memset(i32* %34, i32 0, i32 16)
%36 = load i32, i32* %10
%37 = sdiv i32 %36, 2
%38 = sub nsw i32 %37, 2
store i32 %38, i32* %22
%39 = getelementptr inbounds [3 x i32], [3 x i32]* %15, i64 0, i64 0
store i32 %38, i32* %39
%40 = load i8*, i8** %13
%41 = load i32, i32* %22
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = shl i32 %45, 24
%47 = load i8*, i8** %13
%48 = load i32, i32* %22
%49 = add nsw i32 %48, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %47, i64 %50
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
%54 = shl i32 %53, 16
%55 = or i32 %46, %54
%56 = load i8*, i8** %13
%57 = load i32, i32* %22
%58 = add nsw i32 %57, 2
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %56, i64 %59
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
%63 = shl i32 %62, 8
%64 = or i32 %55, %63
%65 = load i8*, i8** %13
%66 = load i32, i32* %22
%67 = add nsw i32 %66, 3
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %65, i64 %68
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = or i32 %64, %71
%73 = getelementptr inbounds [3 x i32], [3 x i32]* %16, i64 0, i64 0
store i32 %72, i32* %73
store i32 0, i32* %17
%74 = load i32, i32* %10
%75 = icmp slt i32 %74, 16
br i1 %75, label %76, label %77
76: ; preds = %33
store i32 1, i32* %14
br label %155
77: ; preds = %33
%78 = load i32, i32* %10
%79 = sdiv i32 %78, 4
%80 = sub nsw i32 %79, 2
store i32 %80, i32* %22
%81 = getelementptr inbounds [3 x i32], [3 x i32]* %15, i64 0, i64 1
store i32 %80, i32* %81
%82 = load i8*, i8** %13
%83 = load i32, i32* %22
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i8, i8* %82, i64 %84
%86 = load i8, i8* %85
%87 = zext i8 %86 to i32
%88 = shl i32 %87, 24
%89 = load i8*, i8** %13
%90 = load i32, i32* %22
%91 = add nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %89, i64 %92
%94 = load i8, i8* %93
%95 = zext i8 %94 to i32
%96 = shl i32 %95, 16
%97 = or i32 %88, %96
%98 = load i8*, i8** %13
%99 = load i32, i32* %22
%100 = add nsw i32 %99, 2
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %98, i64 %101
%103 = load i8, i8* %102
%104 = zext i8 %103 to i32
%105 = shl i32 %104, 8
%106 = or i32 %97, %105
%107 = load i8*, i8** %13
%108 = load i32, i32* %22
%109 = add nsw i32 %108, 3
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %107, i64 %110
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = or i32 %106, %113
%115 = getelementptr inbounds [3 x i32], [3 x i32]* %16, i64 0, i64 1
store i32 %114, i32* %115
%116 = load i32, i32* %10
%117 = mul nsw i32 %116, 3
%118 = sdiv i32 %117, 4
%119 = sub nsw i32 %118, 2
store i32 %119, i32* %22
%120 = getelementptr inbounds [3 x i32], [3 x i32]* %15, i64 0, i64 2
store i32 %119, i32* %120
%121 = load i8*, i8** %13
%122 = load i32, i32* %22
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i8, i8* %121, i64 %123
%125 = load i8, i8* %124
%126 = zext i8 %125 to i32
%127 = shl i32 %126, 24
%128 = load i8*, i8** %13
%129 = load i32, i32* %22
%130 = add nsw i32 %129, 1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %128, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = shl i32 %134, 16
%136 = or i32 %127, %135
%137 = load i8*, i8** %13
%138 = load i32, i32* %22
%139 = add nsw i32 %138, 2
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i8, i8* %137, i64 %140
%142 = load i8, i8* %141
%143 = zext i8 %142 to i32
%144 = shl i32 %143, 8
%145 = or i32 %136, %144
%146 = load i8*, i8** %13
%147 = load i32, i32* %22
%148 = add nsw i32 %147, 3
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8, i8* %146, i64 %149
%151 = load i8, i8* %150
%152 = zext i8 %151 to i32
%153 = or i32 %145, %152
%154 = getelementptr inbounds [3 x i32], [3 x i32]* %16, i64 0, i64 2
store i32 %153, i32* %154
store i32 3, i32* %14
br label %155
155: ; preds = %77, %76
%156 = load i8*, i8** %12
%157 = getelementptr inbounds i8, i8* %156, i64 0
%158 = load i8, i8* %157
%159 = zext i8 %158 to i32
%160 = shl i32 %159, 16
%161 = load i8*, i8** %12
%162 = getelementptr inbounds i8, i8* %161, i64 1
%163 = load i8, i8* %162
%164 = zext i8 %163 to i32
%165 = shl i32 %164, 8
%166 = or i32 %160, %165
%167 = load i8*, i8** %12
%168 = getelementptr inbounds i8, i8* %167, i64 2
%169 = load i8, i8* %168
%170 = zext i8 %169 to i32
%171 = or i32 %166, %170
store i32 %171, i32* %17
store i32 3, i32* %22
br label %172
172: ; preds = %301, %155
%173 = load i32, i32* %22
%174 = load i32, i32* %8
%175 = icmp slt i32 %173, %174
br i1 %175, label %176, label %304
176: ; preds = %172
%177 = load i32, i32* %17
%178 = shl i32 %177, 8
%179 = load i8*, i8** %12
%180 = load i32, i32* %22
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %179, i64 %181
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = or i32 %178, %184
store i32 %185, i32* %17
store i32 0, i32* %23
br label %186
186: ; preds = %297, %176
%187 = load i32, i32* %23
%188 = load i32, i32* %14
%189 = icmp slt i32 %187, %188
br i1 %189, label %190, label %300
190: ; preds = %186
%191 = load i32, i32* %17
%192 = load i32, i32* %23
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [3 x i32], [3 x i32]* %16, i64 0, i64 %193
%195 = load i32, i32* %194
%196 = icmp eq i32 %191, %195
br i1 %196, label %197, label %296
197: ; preds = %190
%198 = load i32, i32* %22
%199 = sub nsw i32 %198, 3
store i32 %199, i32* %18
%200 = load i32, i32* %22
%201 = add nsw i32 %200, 1
store i32 %201, i32* %19
%202 = load i32, i32* %23
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [3 x i32], [3 x i32]* %15, i64 0, i64 %203
%205 = load i32, i32* %204
store i32 %205, i32* %20
%206 = load i32, i32* %23
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [3 x i32], [3 x i32]* %15, i64 0, i64 %207
%209 = load i32, i32* %208
%210 = add nsw i32 %209, 4
store i32 %210, i32* %21
br label %211
211: ; preds = %235, %197
%212 = load i32, i32* %19
%213 = load i32, i32* %8
%214 = icmp slt i32 %212, %213
br i1 %214, label %215, label %233
215: ; preds = %211
%216 = load i32, i32* %21
%217 = load i32, i32* %10
%218 = icmp slt i32 %216, %217
br i1 %218, label %219, label %233
219: ; preds = %215
%220 = load i8*, i8** %12
%221 = load i32, i32* %19
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %220, i64 %222
%224 = load i8, i8* %223
%225 = zext i8 %224 to i32
%226 = load i8*, i8** %13
%227 = load i32, i32* %21
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i8, i8* %226, i64 %228
%230 = load i8, i8* %229
%231 = zext i8 %230 to i32
%232 = icmp eq i32 %225, %231
br label %233
233: ; preds = %219, %215, %211
%234 = phi i1 [ false, %215 ], [ false, %211 ], [ %232, %219 ]
br i1 %234, label %235, label %240
235: ; preds = %233
%236 = load i32, i32* %19
%237 = add nsw i32 %236, 1
store i32 %237, i32* %19
%238 = load i32, i32* %21
%239 = add nsw i32 %238, 1
store i32 %239, i32* %21
br label %211
240: ; preds = %233
br label %241
241: ; preds = %265, %240
%242 = load i32, i32* %18
%243 = icmp sgt i32 %242, 0
br i1 %243, label %244, label %263
244: ; preds = %241
%245 = load i32, i32* %20
%246 = icmp sgt i32 %245, 0
br i1 %246, label %247, label %263
247: ; preds = %244
%248 = load i8*, i8** %12
%249 = load i32, i32* %18
%250 = sub nsw i32 %249, 1
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i8, i8* %248, i64 %251
%253 = load i8, i8* %252
%254 = zext i8 %253 to i32
%255 = load i8*, i8** %13
%256 = load i32, i32* %20
%257 = sub nsw i32 %256, 1
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %255, i64 %258
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = icmp eq i32 %254, %261
br label %263
263: ; preds = %247, %244, %241
%264 = phi i1 [ false, %244 ], [ false, %241 ], [ %262, %247 ]
br i1 %264, label %265, label %270
265: ; preds = %263
%266 = load i32, i32* %18
%267 = add nsw i32 %266, -1
store i32 %267, i32* %18
%268 = load i32, i32* %20
%269 = add nsw i32 %268, -1
store i32 %269, i32* %20
br label %241
270: ; preds = %263
%271 = load i32, i32* %19
%272 = load i32, i32* %18
%273 = sub nsw i32 %271, %272
%274 = load i32*, i32** %11
%275 = getelementptr inbounds i32, i32* %274, i64 1
%276 = load i32, i32* %275
%277 = load i32*, i32** %11
%278 = getelementptr inbounds i32, i32* %277, i64 0
%279 = load i32, i32* %278
%280 = sub nsw i32 %276, %279
%281 = icmp sgt i32 %273, %280
br i1 %281, label %282, label %295
282: ; preds = %270
%283 = load i32, i32* %18
%284 = load i32*, i32** %11
%285 = getelementptr inbounds i32, i32* %284, i64 0
store i32 %283, i32* %285
%286 = load i32, i32* %19
%287 = load i32*, i32** %11
%288 = getelementptr inbounds i32, i32* %287, i64 1
store i32 %286, i32* %288
%289 = load i32, i32* %20
%290 = load i32*, i32** %11
%291 = getelementptr inbounds i32, i32* %290, i64 2
store i32 %289, i32* %291
%292 = load i32, i32* %21
%293 = load i32*, i32** %11
%294 = getelementptr inbounds i32, i32* %293, i64 3
store i32 %292, i32* %294
store i32 1, i32* %24
br label %295
295: ; preds = %282, %270
br label %296
296: ; preds = %295, %190
br label %297
297: ; preds = %296
%298 = load i32, i32* %23
%299 = add nsw i32 %298, 1
store i32 %299, i32* %23
br label %186
300: ; preds = %186
br label %301
301: ; preds = %300
%302 = load i32, i32* %22
%303 = add nsw i32 %302, 1
store i32 %303, i32* %22
br label %172
304: ; preds = %172
%305 = load i32, i32* %24
store i32 %305, i32* %6
br label %306
306: ; preds = %304, %32
%307 = load i32, i32* %6
ret i32 %307
}

LLVM IR (-O2):
define i32 @textLCS(i8* nocapture %0, i32 %1, i8* nocapture %2, i32 %3, i32* %4) {
%6 = alloca [3 x i32]
%7 = alloca [3 x i32]
%8 = bitcast [3 x i32]* %6 to i8*
%9 = bitcast [3 x i32]* %7 to i8*
%10 = icmp slt i32 %1, 6
%11 = icmp slt i32 %3, 6
%12 = or i1 %10, %11
br i1 %12, label %319, label %13
13: ; preds = %5
%14 = tail call i32 @memset(i32* %4, i32 0, i32 16)
%15 = lshr i32 %3, 1
%16 = add nsw i32 %15, -2
%17 = getelementptr inbounds [3 x i32], [3 x i32]* %6, i64 0, i64 0
store i32 %16, i32* %17
%18 = zext i32 %16 to i64
%19 = getelementptr inbounds i8, i8* %2, i64 %18
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = shl nuw i32 %21, 24
%23 = add nsw i32 %15, -1
%24 = zext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %2, i64 %24
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = shl nuw nsw i32 %27, 16
%29 = or i32 %28, %22
%30 = zext i32 %15 to i64
%31 = getelementptr inbounds i8, i8* %2, i64 %30
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = shl nuw nsw i32 %33, 8
%35 = or i32 %29, %34
%36 = add nuw nsw i32 %15, 1
%37 = zext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %2, i64 %37
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = or i32 %35, %40
%42 = getelementptr inbounds [3 x i32], [3 x i32]* %7, i64 0, i64 0
store i32 %41, i32* %42
%43 = icmp ult i32 %3, 16
br i1 %43, label %102, label %44
44: ; preds = %13
%45 = lshr i32 %3, 2
%46 = add nsw i32 %45, -2
%47 = getelementptr inbounds [3 x i32], [3 x i32]* %6, i64 0, i64 1
store i32 %46, i32* %47
%48 = zext i32 %46 to i64
%49 = getelementptr inbounds i8, i8* %2, i64 %48
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = shl nuw i32 %51, 24
%53 = add nsw i32 %45, -1
%54 = zext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %2, i64 %54
%56 = load i8, i8* %55
%57 = zext i8 %56 to i32
%58 = shl nuw nsw i32 %57, 16
%59 = or i32 %58, %52
%60 = zext i32 %45 to i64
%61 = getelementptr inbounds i8, i8* %2, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i32
%64 = shl nuw nsw i32 %63, 8
%65 = or i32 %59, %64
%66 = add nuw nsw i32 %45, 1
%67 = zext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %2, i64 %67
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
%71 = or i32 %65, %70
%72 = getelementptr inbounds [3 x i32], [3 x i32]* %7, i64 0, i64 1
store i32 %71, i32* %72
%73 = mul nsw i32 %3, 3
%74 = sdiv i32 %73, 4
%75 = add nsw i32 %74, -2
%76 = getelementptr inbounds [3 x i32], [3 x i32]* %6, i64 0, i64 2
store i32 %75, i32* %76
%77 = sext i32 %75 to i64
%78 = getelementptr inbounds i8, i8* %2, i64 %77
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = shl nuw i32 %80, 24
%82 = add nsw i32 %74, -1
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i8, i8* %2, i64 %83
%85 = load i8, i8* %84
%86 = zext i8 %85 to i32
%87 = shl nuw nsw i32 %86, 16
%88 = or i32 %87, %81
%89 = sext i32 %74 to i64
%90 = getelementptr inbounds i8, i8* %2, i64 %89
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = shl nuw nsw i32 %92, 8
%94 = or i32 %88, %93
%95 = add nsw i32 %74, 1
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %2, i64 %96
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = or i32 %94, %99
%101 = getelementptr inbounds [3 x i32], [3 x i32]* %7, i64 0, i64 2
store i32 %100, i32* %101
br label %102
102: ; preds = %44, %13
%103 = getelementptr inbounds i8, i8* %0, i64 1
%104 = load i8, i8* %103
%105 = zext i8 %104 to i32
%106 = shl nuw nsw i32 %105, 8
%107 = load i8, i8* %0
%108 = zext i8 %107 to i32
%109 = shl nuw nsw i32 %108, 16
%110 = or i32 %106, %109
%111 = getelementptr inbounds i8, i8* %0, i64 2
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = or i32 %110, %113
%115 = getelementptr inbounds i32, i32* %4, i64 1
%116 = getelementptr inbounds i32, i32* %4, i64 2
%117 = getelementptr inbounds i32, i32* %4, i64 3
%118 = zext i32 %3 to i64
%119 = zext i32 %1 to i64
%120 = add nsw i32 %1, -3
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds [3 x i32], [3 x i32]* %7, i64 0, i64 0
%123 = load i32, i32* %122
%124 = getelementptr inbounds [3 x i32], [3 x i32]* %6, i64 0, i64 0
%125 = load i32, i32* %124
%126 = add i32 %125, 4
%127 = icmp slt i32 %126, %3
%128 = sext i32 %126 to i64
%129 = zext i32 %125 to i64
%130 = getelementptr inbounds [3 x i32], [3 x i32]* %7, i64 0, i64 1
%131 = load i32, i32* %130
%132 = getelementptr inbounds [3 x i32], [3 x i32]* %6, i64 0, i64 1
%133 = load i32, i32* %132
%134 = add i32 %133, 4
%135 = icmp slt i32 %134, %3
%136 = sext i32 %134 to i64
%137 = zext i32 %133 to i64
%138 = getelementptr inbounds [3 x i32], [3 x i32]* %7, i64 0, i64 2
%139 = load i32, i32* %138
%140 = getelementptr inbounds [3 x i32], [3 x i32]* %6, i64 0, i64 2
%141 = load i32, i32* %140
%142 = add i32 %141, 4
%143 = icmp slt i32 %142, %3
%144 = sext i32 %142 to i64
%145 = zext i32 %141 to i64
br label %146
146: ; preds = %102, %314
%147 = phi i64 [ 3, %102 ], [ %157, %314 ]
%148 = phi i64 [ 0, %102 ], [ %317, %314 ]
%149 = phi i64 [ 4, %102 ], [ %316, %314 ]
%150 = phi i32 [ 0, %102 ], [ %315, %314 ]
%151 = phi i32 [ %114, %102 ], [ %156, %314 ]
%152 = shl i32 %151, 8
%153 = getelementptr inbounds i8, i8* %0, i64 %147
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = or i32 %152, %155
%157 = add nuw nsw i64 %147, 1
%158 = icmp ult i64 %157, %119
%159 = icmp eq i32 %156, %123
br i1 %159, label %160, label %209
160: ; preds = %146
%161 = select i1 %158, i1 %127, i1 false
br i1 %161, label %162, label %181
162: ; preds = %160, %170
%163 = phi i64 [ %171, %170 ], [ %128, %160 ]
%164 = phi i64 [ %172, %170 ], [ %149, %160 ]
%165 = getelementptr inbounds i8, i8* %0, i64 %164
%166 = load i8, i8* %165
%167 = getelementptr inbounds i8, i8* %2, i64 %163
%168 = load i8, i8* %167
%169 = icmp eq i8 %166, %168
br i1 %169, label %170, label %177
170: ; preds = %162
%171 = add nsw i64 %163, 1
%172 = add nuw nsw i64 %164, 1
%173 = trunc i64 %172 to i32
%174 = icmp slt i32 %173, %1
%175 = icmp slt i64 %171, %118
%176 = select i1 %174, i1 %175, i1 false
br i1 %176, label %162, label %177
177: ; preds = %162, %170
%178 = phi i64 [ %172, %170 ], [ %164, %162 ]
%179 = phi i64 [ %171, %170 ], [ %163, %162 ]
%180 = trunc i64 %179 to i32
br label %181
181: ; preds = %177, %160
%182 = phi i32 [ %126, %160 ], [ %180, %177 ]
%183 = phi i64 [ %157, %160 ], [ %178, %177 ]
%184 = trunc i64 %183 to i32
br label %185
185: ; preds = %192, %181
%186 = phi i64 [ %196, %192 ], [ %129, %181 ]
%187 = phi i64 [ %193, %192 ], [ %148, %181 ]
%188 = icmp sgt i64 %187, 0
%189 = trunc i64 %186 to i32
%190 = icmp sgt i32 %189, 0
%191 = select i1 %188, i1 %190, i1 false
br i1 %191, label %192, label %200
192: ; preds = %185
%193 = add nsw i64 %187, -1
%194 = getelementptr inbounds i8, i8* %0, i64 %193
%195 = load i8, i8* %194
%196 = add nsw i64 %186, -1
%197 = getelementptr inbounds i8, i8* %2, i64 %196
%198 = load i8, i8* %197
%199 = icmp eq i8 %195, %198
br i1 %199, label %185, label %200
200: ; preds = %185, %192
%201 = trunc i64 %187 to i32
%202 = sub nsw i32 %184, %201
%203 = load i32, i32* %115
%204 = load i32, i32* %4
%205 = sub nsw i32 %203, %204
%206 = icmp sgt i32 %202, %205
br i1 %206, label %207, label %209
207: ; preds = %200
%208 = trunc i64 %186 to i32
store i32 %201, i32* %4
store i32 %184, i32* %115
store i32 %208, i32* %116
store i32 %182, i32* %117
br label %209
209: ; preds = %146, %207, %200
%210 = phi i32 [ 1, %207 ], [ %150, %200 ], [ %150, %146 ]
br i1 %43, label %314, label %211
211: ; preds = %209
%212 = icmp eq i32 %156, %131
br i1 %212, label %213, label %262
213: ; preds = %211
%214 = select i1 %158, i1 %135, i1 false
br i1 %214, label %215, label %234
215: ; preds = %213, %223
%216 = phi i64 [ %224, %223 ], [ %136, %213 ]
%217 = phi i64 [ %225, %223 ], [ %149, %213 ]
%218 = getelementptr inbounds i8, i8* %0, i64 %217
%219 = load i8, i8* %218
%220 = getelementptr inbounds i8, i8* %2, i64 %216
%221 = load i8, i8* %220
%222 = icmp eq i8 %219, %221
br i1 %222, label %223, label %230
223: ; preds = %215
%224 = add nsw i64 %216, 1
%225 = add nuw nsw i64 %217, 1
%226 = trunc i64 %225 to i32
%227 = icmp slt i32 %226, %1
%228 = icmp slt i64 %224, %118
%229 = select i1 %227, i1 %228, i1 false
br i1 %229, label %215, label %230
230: ; preds = %223, %215
%231 = phi i64 [ %225, %223 ], [ %217, %215 ]
%232 = phi i64 [ %224, %223 ], [ %216, %215 ]
%233 = trunc i64 %232 to i32
br label %234
234: ; preds = %230, %213
%235 = phi i32 [ %134, %213 ], [ %233, %230 ]
%236 = phi i64 [ %157, %213 ], [ %231, %230 ]
%237 = trunc i64 %236 to i32
br label %238
238: ; preds = %245, %234
%239 = phi i64 [ %249, %245 ], [ %137, %234 ]
%240 = phi i64 [ %246, %245 ], [ %148, %234 ]
%241 = icmp sgt i64 %240, 0
%242 = trunc i64 %239 to i32
%243 = icmp sgt i32 %242, 0
%244 = select i1 %241, i1 %243, i1 false
br i1 %244, label %245, label %253
245: ; preds = %238
%246 = add nsw i64 %240, -1
%247 = getelementptr inbounds i8, i8* %0, i64 %246
%248 = load i8, i8* %247
%249 = add nsw i64 %239, -1
%250 = getelementptr inbounds i8, i8* %2, i64 %249
%251 = load i8, i8* %250
%252 = icmp eq i8 %248, %251
br i1 %252, label %238, label %253
253: ; preds = %245, %238
%254 = trunc i64 %240 to i32
%255 = sub nsw i32 %237, %254
%256 = load i32, i32* %115
%257 = load i32, i32* %4
%258 = sub nsw i32 %256, %257
%259 = icmp sgt i32 %255, %258
br i1 %259, label %260, label %262
260: ; preds = %253
%261 = trunc i64 %239 to i32
store i32 %254, i32* %4
store i32 %237, i32* %115
store i32 %261, i32* %116
store i32 %235, i32* %117
br label %262
262: ; preds = %211, %253, %260
%263 = phi i32 [ 1, %260 ], [ %210, %253 ], [ %210, %211 ]
%264 = icmp eq i32 %156, %139
br i1 %264, label %265, label %314
265: ; preds = %262
%266 = select i1 %158, i1 %143, i1 false
br i1 %266, label %267, label %286
267: ; preds = %265, %275
%268 = phi i64 [ %276, %275 ], [ %144, %265 ]
%269 = phi i64 [ %277, %275 ], [ %149, %265 ]
%270 = getelementptr inbounds i8, i8* %0, i64 %269
%271 = load i8, i8* %270
%272 = getelementptr inbounds i8, i8* %2, i64 %268
%273 = load i8, i8* %272
%274 = icmp eq i8 %271, %273
br i1 %274, label %275, label %282
275: ; preds = %267
%276 = add nsw i64 %268, 1
%277 = add nuw nsw i64 %269, 1
%278 = trunc i64 %277 to i32
%279 = icmp slt i32 %278, %1
%280 = icmp slt i64 %276, %118
%281 = select i1 %279, i1 %280, i1 false
br i1 %281, label %267, label %282
282: ; preds = %275, %267
%283 = phi i64 [ %277, %275 ], [ %269, %267 ]
%284 = phi i64 [ %276, %275 ], [ %268, %267 ]
%285 = trunc i64 %284 to i32
br label %286
286: ; preds = %282, %265
%287 = phi i32 [ %142, %265 ], [ %285, %282 ]
%288 = phi i64 [ %157, %265 ], [ %283, %282 ]
%289 = trunc i64 %288 to i32
br label %290
290: ; preds = %297, %286
%291 = phi i64 [ %301, %297 ], [ %145, %286 ]
%292 = phi i64 [ %298, %297 ], [ %148, %286 ]
%293 = icmp sgt i64 %292, 0
%294 = trunc i64 %291 to i32
%295 = icmp sgt i32 %294, 0
%296 = select i1 %293, i1 %295, i1 false
br i1 %296, label %297, label %305
297: ; preds = %290
%298 = add nsw i64 %292, -1
%299 = getelementptr inbounds i8, i8* %0, i64 %298
%300 = load i8, i8* %299
%301 = add nsw i64 %291, -1
%302 = getelementptr inbounds i8, i8* %2, i64 %301
%303 = load i8, i8* %302
%304 = icmp eq i8 %300, %303
br i1 %304, label %290, label %305
305: ; preds = %297, %290
%306 = trunc i64 %292 to i32
%307 = sub nsw i32 %289, %306
%308 = load i32, i32* %115
%309 = load i32, i32* %4
%310 = sub nsw i32 %308, %309
%311 = icmp sgt i32 %307, %310
br i1 %311, label %312, label %314
312: ; preds = %305
%313 = trunc i64 %291 to i32
store i32 %306, i32* %4
store i32 %289, i32* %115
store i32 %313, i32* %116
store i32 %287, i32* %117
br label %314
314: ; preds = %262, %305, %312, %209
%315 = phi i32 [ %210, %209 ], [ 1, %312 ], [ %263, %305 ], [ %263, %262 ]
%316 = add nuw nsw i64 %149, 1
%317 = add nuw nsw i64 %148, 1
%318 = icmp eq i64 %317, %121
br i1 %318, label %319, label %146
319: ; preds = %314, %5
%320 = phi i32 [ 0, %5 ], [ %315, %314 ]
ret i32 %320
}