#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 min(int, int);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ scanf(char *, char *);
int strlen(char *);
int main(void) {
  char a[256];
  char b[256];
  int al, bl;
  int d[256 + 1][256 + 1];
  int i, j;
  scanf("%s", a);
  scanf("%s", b);
  al = strlen(a);
  bl = strlen(b);
  for (i = 0; i <= al; i++)
    d[i][0] = i;
  for (i = 0; i <= bl; i++)
    d[0][i] = i;
  for (i = 1; i <= al; i++) {
    for (j = 1; j <= bl; j++) {
      d[i][j] = min(min(d[i][j - 1], d[i - 1][j]) + 1,
                    d[i - 1][j - 1] + (a[i - 1] == b[j - 1] ? 0 : 1));
    }
  }
  printf("%d\n", d[al][bl]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40a30,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x110(%rbp),%rsi
lea    0xea0(%rip),%rdi
call   1060 <scanf@plt>
lea    -0x210(%rbp),%rsi
lea    0xe8d(%rip),%rdi
call   1060 <scanf@plt>
lea    -0x110(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x214(%rbp)
lea    -0x210(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x218(%rbp)
movl   $0x0,-0x40a24(%rbp)
mov    -0x40a24(%rbp),%eax
cmp    -0x214(%rbp),%eax
jg     11ec <main+0xac>
mov    -0x40a24(%rbp),%ecx
movslq -0x40a24(%rbp),%rdx
lea    -0x40a20(%rbp),%rax
imul   $0x404,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x40a24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40a24(%rbp)
jmp    11a6 <main+0x66>
movl   $0x0,-0x40a24(%rbp)
mov    -0x40a24(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     1230 <main+0xf0>
mov    -0x40a24(%rbp),%ecx
movslq -0x40a24(%rbp),%rax
mov    %ecx,-0x40a20(%rbp,%rax,4)
mov    -0x40a24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40a24(%rbp)
jmp    11f6 <main+0xb6>
movl   $0x1,-0x40a24(%rbp)
mov    -0x40a24(%rbp),%eax
cmp    -0x214(%rbp),%eax
jg     1378 <main+0x238>
movl   $0x1,-0x40a28(%rbp)
mov    -0x40a28(%rbp),%eax
cmp    -0x218(%rbp),%eax
jg     135f <main+0x21f>
movslq -0x40a24(%rbp),%rcx
lea    -0x40a20(%rbp),%rax
imul   $0x404,%rcx,%rcx
add    %rcx,%rax
mov    -0x40a28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x40a24(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x40a20(%rbp),%rax
imul   $0x404,%rcx,%rcx
add    %rcx,%rax
movslq -0x40a28(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
call   1050 <min@plt>
mov    %eax,%edi
add    $0x1,%edi
mov    -0x40a24(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x40a20(%rbp),%rax
imul   $0x404,%rcx,%rcx
add    %rcx,%rax
mov    -0x40a28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x40a24(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0x110(%rbp,%rax,1),%edx
ff
mov    -0x40a28(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0x210(%rbp,%rax,1),%r8d
ff ff
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    %r8d,%edx
cmove  %ecx,%eax
add    %eax,%esi
call   1050 <min@plt>
mov    %eax,%edx
movslq -0x40a24(%rbp),%rcx
lea    -0x40a20(%rbp),%rax
imul   $0x404,%rcx,%rcx
add    %rcx,%rax
movslq -0x40a28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40a28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40a28(%rbp)
jmp    1256 <main+0x116>
jmp    1364 <main+0x224>
mov    -0x40a24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40a24(%rbp)
jmp    123a <main+0xfa>
movslq -0x214(%rbp),%rcx
lea    -0x40a20(%rbp),%rax
imul   $0x404,%rcx,%rcx
add    %rcx,%rax
movslq -0x218(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xc62(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x40a30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x40a18,%rsp
lea    0xf38(%rip),%rbx
lea    0x110(%rsp),%r14
mov    %rbx,%rdi
mov    %r14,%rsi
call   1060 <scanf@plt>
lea    0x10(%rsp),%r15
mov    %rbx,%rdi
mov    %r15,%rsi
call   1060 <scanf@plt>
mov    %r14,%rdi
call   1030 <strlen@plt>
mov    %eax,%ebx
mov    %r15,%rdi
call   1030 <strlen@plt>
mov    %eax,%r15d
test   %ebx,%ebx
js     1232 <main+0xf2>
mov    %ebx,%edx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%ebx
jae    11ac <main+0x6c>
xor    %eax,%eax
jmp    11ed <main+0xad>
and    $0xfffffffc,%edx
lea    0x210(%rsp),%rsi
xor    %eax,%eax
nopl   0x0(%rax)
mov    %eax,(%rsi)
lea    0x1(%rax),%edi
mov    %edi,0x404(%rsi)
lea    0x2(%rax),%edi
mov    %edi,0x808(%rsi)
lea    0x3(%rax),%edi
mov    %edi,0xc0c(%rsi)
add    $0x4,%rax
add    $0x1010,%rsi
cmp    %rdx,%rax
jne    11c0 <main+0x80>
test   %rcx,%rcx
je     1232 <main+0xf2>
mov    %rax,%rdx
shl    $0xa,%rdx
lea    (%rdx,%rax,4),%rdx
add    %rsp,%rdx
add    $0x210,%rdx
mov    %rcx,%rsi
shl    $0xa,%rsi
lea    (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,(%rdx,%rsi,1)
add    $0x1,%eax
add    $0x404,%rsi
cmp    %rsi,%rcx
jne    1220 <main+0xe0>
test   %r15d,%r15d
js     13d0 <main+0x290>
lea    0x1(%r15),%eax
cmp    $0x7,%r15d
jae    124c <main+0x10c>
xor    %ecx,%ecx
jmp    13c0 <main+0x280>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    127a <main+0x13a>
movdqa 0xd8d(%rip),%xmm0
xor    %edi,%edi
jmp    1365 <main+0x225>
and    $0xfffffffffffffffc,%rsi
movdqa 0xd7a(%rip),%xmm0
xor    %edi,%edi
movdqa 0xd7f(%rip),%xmm8
movdqa 0xd86(%rip),%xmm9
movdqa 0xd8d(%rip),%xmm10
movdqa 0xd95(%rip),%xmm4
movdqa 0xd9d(%rip),%xmm5
movdqa 0xda5(%rip),%xmm6
movdqa 0xdad(%rip),%xmm7
movdqa 0xdb5(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqa %xmm0,0x210(%rsp,%rdi,4)
movdqa %xmm2,0x220(%rsp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqa %xmm2,0x230(%rsp,%rdi,4)
movdqa %xmm3,0x240(%rsp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqa %xmm2,0x250(%rsp,%rdi,4)
movdqa %xmm3,0x260(%rsp,%rdi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqa %xmm2,0x270(%rsp,%rdi,4)
movdqa %xmm3,0x280(%rsp,%rdi,4)
add    $0x20,%rdi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    12d0 <main+0x190>
test   %rdx,%rdx
je     13b0 <main+0x270>
lea    (%rsp,%rdi,4),%rsi
add    $0x220,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xc8d(%rip),%xmm1
movdqa 0xc95(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqa %xmm0,-0x10(%rsi,%rdi,1)
movdqa %xmm3,(%rsi,%rdi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1390 <main+0x250>
cmp    %rax,%rcx
je     13d0 <main+0x290>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,0x210(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13c0 <main+0x280>
mov    %rbx,0x8(%rsp)
test   %ebx,%ebx
jle    146f <main+0x32f>
lea    0x1(%r15),%r13d
mov    0x8(%rsp),%rax
lea    0x1(%rax),%r12d
add    $0xffffffffffffffff,%r13
mov    $0x1,%ebx
lea    0x210(%rsp),%rbp
jmp    1410 <main+0x2d0>
nopl   (%rax)
add    $0x1,%rbx
add    $0x404,%rbp
cmp    %r12,%rbx
je     146f <main+0x32f>
test   %r15d,%r15d
jle    1400 <main+0x2c0>
mov    %rbx,%rax
shl    $0xa,%rax
lea    (%rax,%rbx,4),%rax
mov    0x210(%rsp,%rax,1),%eax
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
mov    0x4(%rbp,%r14,4),%esi
mov    %eax,%edi
call   1050 <min@plt>
movzbl 0x10f(%rsp,%rbx,1),%ecx
xor    %esi,%esi
cmp    0x10(%rsp,%r14,1),%cl
lea    0x1(%rax),%edi
setne  %sil
add    0x0(%rbp,%r14,4),%esi
call   1050 <min@plt>
mov    %eax,0x408(%rbp,%r14,4)
add    $0x1,%r14
cmp    %r14,%r13
jne    1430 <main+0x2f0>
jmp    1400 <main+0x2c0>
movslq 0x8(%rsp),%rax
movslq %r15d,%rcx
mov    %rax,%rdx
shl    $0xa,%rdx
lea    (%rdx,%rax,4),%rax
add    %rsp,%rax
add    $0x210,%rax
mov    (%rax,%rcx,4),%esi
lea    0xbfe(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x40a18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"%s\00"
@.str.1 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca [256 x i8]
%2 = alloca [256 x i8]
%3 = alloca [257 x [257 x i32]]
%4 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 0
%5 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 0
%6 = bitcast [257 x [257 x i32]]* %3 to i8*
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %4)
%8 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %5)
%9 = call i32 @strlen(i8* %4)
%10 = call i32 @strlen(i8* %5)
%11 = icmp slt i32 %9, 0
br i1 %11, label %31, label %12
12: ; preds = %0
%13 = add nuw i32 %9, 1
%14 = zext i32 %13 to i64
%15 = add nsw i64 %14, -1
%16 = and i64 %14, 3
%17 = icmp ult i64 %15, 3
br i1 %17, label %20, label %18
18: ; preds = %12
%19 = and i64 %14, 4294967292
br label %101
20: ; preds = %101, %12
%21 = phi i64 [ 0, %12 ], [ %115, %101 ]
%22 = icmp eq i64 %16, 0
br i1 %22, label %31, label %23
23: ; preds = %20, %23
%24 = phi i64 [ %28, %23 ], [ %21, %20 ]
%25 = phi i64 [ %29, %23 ], [ 0, %20 ]
%26 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %24, i64 0
%27 = trunc i64 %24 to i32
store i32 %27, i32* %26
%28 = add nuw nsw i64 %24, 1
%29 = add i64 %25, 1
%30 = icmp eq i64 %29, %16
br i1 %30, label %31, label %23
31: ; preds = %20, %23, %0
%32 = icmp slt i32 %10, 0
br i1 %32, label %118, label %33
33: ; preds = %31
%34 = add nuw i32 %10, 1
%35 = zext i32 %34 to i64
%36 = icmp ult i32 %10, 7
br i1 %36, label %99, label %37
37: ; preds = %33
%38 = and i64 %35, 4294967288
%39 = add nsw i64 %38, -8
%40 = lshr exact i64 %39, 3
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 3
%43 = icmp ult i64 %39, 24
br i1 %43, label %80, label %44
44: ; preds = %37
%45 = and i64 %41, 4611686018427387900
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %76, %46 ]
%48 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %44 ], [ %77, %46 ]
%49 = phi i64 [ 0, %44 ], [ %78, %46 ]
%50 = add <4 x i32> %48, <i32 4, i32 4, i32 4, i32 4>
%51 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 0, i64 %47
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %52
%53 = getelementptr inbounds i32, i32* %51, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %50, <4 x i32>* %54
%55 = or i64 %47, 8
%56 = add <4 x i32> %48, <i32 8, i32 8, i32 8, i32 8>
%57 = add <4 x i32> %48, <i32 12, i32 12, i32 12, i32 12>
%58 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 0, i64 %55
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %56, <4 x i32>* %59
%60 = getelementptr inbounds i32, i32* %58, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> %57, <4 x i32>* %61
%62 = or i64 %47, 16
%63 = add <4 x i32> %48, <i32 16, i32 16, i32 16, i32 16>
%64 = add <4 x i32> %48, <i32 20, i32 20, i32 20, i32 20>
%65 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 0, i64 %62
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %63, <4 x i32>* %66
%67 = getelementptr inbounds i32, i32* %65, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %68
%69 = or i64 %47, 24
%70 = add <4 x i32> %48, <i32 24, i32 24, i32 24, i32 24>
%71 = add <4 x i32> %48, <i32 28, i32 28, i32 28, i32 28>
%72 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 0, i64 %69
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %70, <4 x i32>* %73
%74 = getelementptr inbounds i32, i32* %72, i64 4
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %75
%76 = add nuw i64 %47, 32
%77 = add <4 x i32> %48, <i32 32, i32 32, i32 32, i32 32>
%78 = add i64 %49, 4
%79 = icmp eq i64 %78, %45
br i1 %79, label %80, label %46
80: ; preds = %46, %37
%81 = phi i64 [ 0, %37 ], [ %76, %46 ]
%82 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %37 ], [ %77, %46 ]
%83 = icmp eq i64 %42, 0
br i1 %83, label %97, label %84
84: ; preds = %80, %84
%85 = phi i64 [ %93, %84 ], [ %81, %80 ]
%86 = phi <4 x i32> [ %94, %84 ], [ %82, %80 ]
%87 = phi i64 [ %95, %84 ], [ 0, %80 ]
%88 = add <4 x i32> %86, <i32 4, i32 4, i32 4, i32 4>
%89 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 0, i64 %85
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> %86, <4 x i32>* %90
%91 = getelementptr inbounds i32, i32* %89, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> %88, <4 x i32>* %92
%93 = add nuw i64 %85, 8
%94 = add <4 x i32> %86, <i32 8, i32 8, i32 8, i32 8>
%95 = add i64 %87, 1
%96 = icmp eq i64 %95, %42
br i1 %96, label %97, label %84
97: ; preds = %84, %80
%98 = icmp eq i64 %38, %35
br i1 %98, label %118, label %99
99: ; preds = %33, %97
%100 = phi i64 [ 0, %33 ], [ %38, %97 ]
br label %126
101: ; preds = %101, %18
%102 = phi i64 [ 0, %18 ], [ %115, %101 ]
%103 = phi i64 [ 0, %18 ], [ %116, %101 ]
%104 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %102, i64 0
%105 = trunc i64 %102 to i32
store i32 %105, i32* %104
%106 = or i64 %102, 1
%107 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %106, i64 0
%108 = trunc i64 %106 to i32
store i32 %108, i32* %107
%109 = or i64 %102, 2
%110 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %109, i64 0
%111 = trunc i64 %109 to i32
store i32 %111, i32* %110
%112 = or i64 %102, 3
%113 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %112, i64 0
%114 = trunc i64 %112 to i32
store i32 %114, i32* %113
%115 = add nuw nsw i64 %102, 4
%116 = add i64 %103, 4
%117 = icmp eq i64 %116, %19
br i1 %117, label %20, label %101
118: ; preds = %126, %97, %31
%119 = icmp slt i32 %9, 1
br i1 %119, label %162, label %120
120: ; preds = %118
%121 = icmp slt i32 %10, 1
%122 = add i32 %10, 1
%123 = add nuw i32 %9, 1
%124 = zext i32 %123 to i64
%125 = zext i32 %122 to i64
br label %132
126: ; preds = %99, %126
%127 = phi i64 [ %130, %126 ], [ %100, %99 ]
%128 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 0, i64 %127
%129 = trunc i64 %127 to i32
store i32 %129, i32* %128
%130 = add nuw nsw i64 %127, 1
%131 = icmp eq i64 %130, %35
br i1 %131, label %118, label %126
132: ; preds = %120, %159
%133 = phi i64 [ 1, %120 ], [ %160, %159 ]
br i1 %121, label %159, label %134
134: ; preds = %132
%135 = add nsw i64 %133, -1
%136 = getelementptr inbounds [256 x i8], [256 x i8]* %1, i64 0, i64 %135
%137 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %133, i64 0
%138 = load i32, i32* %137
br label %139
139: ; preds = %134, %139
%140 = phi i32 [ %138, %134 ], [ %155, %139 ]
%141 = phi i64 [ 1, %134 ], [ %157, %139 ]
%142 = add nsw i64 %141, -1
%143 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %135, i64 %141
%144 = load i32, i32* %143
%145 = call i32 @min(i32 %140, i32 %144)
%146 = add nsw i32 %145, 1
%147 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %135, i64 %142
%148 = load i32, i32* %147
%149 = load i8, i8* %136
%150 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %142
%151 = load i8, i8* %150
%152 = icmp ne i8 %149, %151
%153 = zext i1 %152 to i32
%154 = add nsw i32 %148, %153
%155 = call i32 @min(i32 %146, i32 %154)
%156 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %133, i64 %141
store i32 %155, i32* %156
%157 = add nuw nsw i64 %141, 1
%158 = icmp eq i64 %157, %125
br i1 %158, label %159, label %139
159: ; preds = %139, %132
%160 = add nuw nsw i64 %133, 1
%161 = icmp eq i64 %160, %124
br i1 %161, label %162, label %132
162: ; preds = %159, %118
%163 = sext i32 %9 to i64
%164 = sext i32 %10 to i64
%165 = getelementptr inbounds [257 x [257 x i32]], [257 x [257 x i32]]* %3, i64 0, i64 %163, i64 %164
%166 = load i32, i32* %165
%167 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %166)
ret i32 0
}