#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*/ printf(char *, ...);
int one_pad_crack_row(unsigned char m[7][7], unsigned char values[7]) {
  int end = 0;
  int i, j, k, l;
  char c[100];
  int debug;
  int _i, _j, _k;
  i = 0;
  j = 0;
  k = 0;
  values[i] = 32;
  j = 1;
  k = 2;
  while (1) {
    debug = 0;
    if (debug == 1) {
      printf("Checking i:%d j:%d k:%d\n", i, j, k);
      for (_i = 0; _i < 7; _i++) {
        for (_j = 0; _j < 7; _j++) {
          printf("%02x ", m[_i][_j]);
        }
        printf("\n");
      }
    }
    if (values[0] >= 122) {
      return 0;
    }
    if (i >= (7 - 1)) {
      for (l = 0; l < 7; l++)
        printf("%c ", values[l]);
      printf("\n");
      i = 0;
      values[i] += 1;
      j = 1;
      k = 2;
      continue;
      continue;
    }
    if (k >= 7) {
      i += 1;
      j = i + 1;
      k = j + 1;
      continue;
    }
    values[j] = m[i][j] ^ values[i];
    values[k] = m[i][k] ^ values[i];
    if ((values[j] < 32 || values[j] > 122) ||
        (values[j] >= 47 && values[j] <= 62) ||
        (values[j] >= 33 && values[j] <= 43) || (values[j] == 64) ||
        (values[k] < 32 || values[k] > 122) ||
        (values[k] >= 47 && values[k] <= 62) ||
        (values[k] >= 33 && values[k] <= 43) || (values[k] == 64) ||
        ((values[j] ^ values[k]) != m[j][k])) {
      i = 0;
      values[i] += 1;
      j = 1;
      k = 2;
    } else {
      j++;
      k++;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<one_pad_crack_row>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
movl   $0x1,-0x1c(%rbp)
movl   $0x2,-0x20(%rbp)
movl   $0x0,-0x94(%rbp)
cmpl   $0x1,-0x94(%rbp)
jne    121b <one_pad_crack_row+0x10b>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
lea    0xe80(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x98(%rbp)
cmpl   $0x7,-0x98(%rbp)
jge    1216 <one_pad_crack_row+0x106>
movl   $0x0,-0x9c(%rbp)
cmpl   $0x7,-0x9c(%rbp)
jge    11f4 <one_pad_crack_row+0xe4>
mov    -0x8(%rbp),%rax
movslq -0x98(%rbp),%rcx
imul   $0x7,%rcx,%rcx
add    %rcx,%rax
movslq -0x9c(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xe40(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    11a8 <one_pad_crack_row+0x98>
lea    0xe1c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1191 <one_pad_crack_row+0x81>
jmp    121b <one_pad_crack_row+0x10b>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x7a,%eax
jl     1236 <one_pad_crack_row+0x126>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret
cmpl   $0x6,-0x18(%rbp)
jl     12b3 <one_pad_crack_row+0x1a3>
movl   $0x0,-0x24(%rbp)
cmpl   $0x7,-0x24(%rbp)
jge    1279 <one_pad_crack_row+0x169>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xdbb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1247 <one_pad_crack_row+0x137>
lea    0xd97(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x1,%edx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x1c(%rbp)
movl   $0x2,-0x20(%rbp)
jmp    1159 <one_pad_crack_row+0x49>
cmpl   $0x7,-0x20(%rbp)
jl     12dd <one_pad_crack_row+0x1cd>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1159 <one_pad_crack_row+0x49>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x7,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x7,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jl     14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jg     14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jl     1395 <one_pad_crack_row+0x285>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x3e,%eax
jle    14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
jl     13bf <one_pad_crack_row+0x2af>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x2b,%eax
jle    14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x40,%eax
je     14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jl     14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jg     14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jl     1428 <one_pad_crack_row+0x318>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x3e,%eax
jle    14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
jl     1452 <one_pad_crack_row+0x342>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x2b,%eax
jle    14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x40,%eax
je     14a0 <one_pad_crack_row+0x390>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x7,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     14cc <one_pad_crack_row+0x3bc>
movl   $0x0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
add    $0x1,%edx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x1c(%rbp)
movl   $0x2,-0x20(%rbp)
jmp    14de <one_pad_crack_row+0x3ce>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1159 <one_pad_crack_row+0x49>

x86 assembly (clang, -O2):
<one_pad_crack_row>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
movb   $0x20,(%rsi)
mov    $0x2,%esi
mov    $0x1,%r8d
xor    %r12d,%r12d
mov    $0x20,%dl
lea    0xeb8(%rip),%r15
jmp    116d <one_pad_crack_row+0x4d>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r12),%eax
lea    0x2(%r12),%r8d
add    $0x3,%r12d
mov    %r12d,%esi
mov    %eax,%r12d
cmp    $0x79,%dl
ja     12db <one_pad_crack_row+0x1bb>
cmp    $0x6,%r12d
jge    1240 <one_pad_crack_row+0x120>
cmp    $0x7,%esi
jge    1150 <one_pad_crack_row+0x30>
movslq %r12d,%rax
movslq %r8d,%rdx
lea    0x0(,%rax,8),%rdi
sub    %rax,%rdi
add    %r14,%rdi
movzbl (%rbx,%rax,1),%ecx
xor    (%rdx,%rdi,1),%cl
mov    %cl,(%rbx,%rdx,1)
movslq %esi,%r9
movzbl (%rbx,%rax,1),%eax
xor    (%r9,%rdi,1),%al
mov    %al,(%rbx,%r9,1)
movzbl (%rbx,%rdx,1),%edi
lea    -0x7b(%rdi),%ecx
cmp    $0xa5,%cl
jb     12c0 <one_pad_crack_row+0x1a0>
lea    -0x2f(%rdi),%ecx
cmp    $0x10,%cl
jb     12c0 <one_pad_crack_row+0x1a0>
cmp    $0x40,%dil
je     12c0 <one_pad_crack_row+0x1a0>
lea    -0x21(%rdi),%ecx
cmp    $0xb,%cl
jb     12c0 <one_pad_crack_row+0x1a0>
lea    -0x7b(%rax),%ecx
cmp    $0xa5,%cl
jb     12c0 <one_pad_crack_row+0x1a0>
lea    -0x2f(%rax),%ecx
cmp    $0x10,%cl
jb     12c0 <one_pad_crack_row+0x1a0>
cmp    $0x40,%al
je     12c0 <one_pad_crack_row+0x1a0>
lea    -0x21(%rax),%ecx
cmp    $0xb,%cl
jb     12c0 <one_pad_crack_row+0x1a0>
xor    %al,%dil
lea    0x0(,%rdx,8),%rax
sub    %rdx,%rax
add    %r14,%rax
cmp    (%r9,%rax,1),%dil
jne    12c0 <one_pad_crack_row+0x1a0>
add    $0x1,%r8d
add    $0x1,%esi
movzbl (%rbx),%edx
jmp    1164 <one_pad_crack_row+0x44>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl %dl,%esi
xor    %r12d,%r12d
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1(%rbx),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2(%rbx),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3(%rbx),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4(%rbx),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5(%rbx),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6(%rbx),%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movzbl (%rbx),%edx
add    $0x1,%dl
mov    %dl,(%rbx)
jmp    12cb <one_pad_crack_row+0x1ab>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx),%edx
add    $0x1,%dl
mov    %dl,(%rbx)
xor    %r12d,%r12d
mov    $0x1,%r8d
mov    $0x2,%esi
jmp    1164 <one_pad_crack_row+0x44>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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