#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 */
scalar_t__ is_corner(int, int, int const, int const);
void fold_dotstream(const char dot_stream[], const int width, const int height,
                    char dot_array[]) {
  int column, row;
  int input_position = 0;
  if (height % 2) {
    for (row = 0; row < height; row++) {
      for (column = 0; column < width; column++) {
        if (!((column + row) % 2)) {
          if (is_corner(column, row, width, height)) {
            dot_array[(row * width) + column] = 'C';
          } else {
            dot_array[((height - row - 1) * width) + column] =
                dot_stream[input_position];
            input_position++;
          }
        } else {
          dot_array[((height - row - 1) * width) + column] = ' ';
        }
      }
    }
    dot_array[width - 2] = dot_stream[input_position];
    input_position++;
    dot_array[(height * width) - 2] = dot_stream[input_position];
    input_position++;
    dot_array[(width * 2) - 1] = dot_stream[input_position];
    input_position++;
    dot_array[((height - 1) * width) - 1] = dot_stream[input_position];
    input_position++;
    dot_array[0] = dot_stream[input_position];
    input_position++;
    dot_array[(height - 1) * width] = dot_stream[input_position];
  } else {
    for (column = 0; column < width; column++) {
      for (row = 0; row < height; row++) {
        if (!((column + row) % 2)) {
          if (is_corner(column, row, width, height)) {
            dot_array[(row * width) + column] = 'C';
          } else {
            dot_array[(row * width) + column] = dot_stream[input_position];
            input_position++;
          }
        } else {
          dot_array[(row * width) + column] = ' ';
        }
      }
    }
    dot_array[((height - 1) * width) - 1] = dot_stream[input_position];
    input_position++;
    dot_array[(height - 2) * width] = dot_stream[input_position];
    input_position++;
    dot_array[(height * width) - 2] = dot_stream[input_position];
    input_position++;
    dot_array[((height - 1) * width) + 1] = dot_stream[input_position];
    input_position++;
    dot_array[width - 1] = dot_stream[input_position];
    input_position++;
    dot_array[0] = dot_stream[input_position];
  }
}


x86 assembly (clang, -O0):
<fold_dotstream>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1303 <fold_dotstream+0x1f3>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1227 <fold_dotstream+0x117>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1214 <fold_dotstream+0x104>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11e6 <fold_dotstream+0xd6>
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1030 <is_corner@plt>
cmp    $0x0,%rax
je     11b3 <fold_dotstream+0xa3>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x43,(%rax,%rcx,1)
jmp    11e1 <fold_dotstream+0xd1>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1201 <fold_dotstream+0xf1>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    1206 <fold_dotstream+0xf6>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    115b <fold_dotstream+0x4b>
jmp    1219 <fold_dotstream+0x109>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1148 <fold_dotstream+0x38>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    14b8 <fold_dotstream+0x3a8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13dd <fold_dotstream+0x2cd>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13ca <fold_dotstream+0x2ba>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    13a2 <fold_dotstream+0x292>
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1030 <is_corner@plt>
cmp    $0x0,%rax
je     1375 <fold_dotstream+0x265>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x43,(%rax,%rcx,1)
jmp    139d <fold_dotstream+0x28d>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13b7 <fold_dotstream+0x2a7>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    13bc <fold_dotstream+0x2ac>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    131d <fold_dotstream+0x20d>
jmp    13cf <fold_dotstream+0x2bf>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    130a <fold_dotstream+0x1fa>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x2,%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fold_dotstream>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,0x8(%rsp)
mov    %rdi,0x18(%rsp)
mov    %edx,%r15d
mov    %esi,%r12d
test   $0x1,%dl
mov    %esi,0x4(%rsp)
mov    %rdx,0x20(%rsp)
jne    11db <fold_dotstream+0xcb>
test   %esi,%esi
jle    129f <fold_dotstream+0x18f>
xor    %ebx,%ebx
mov    0x8(%rsp),%r13
xor    %r14d,%r14d
jmp    117b <fold_dotstream+0x6b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
mov    0x10(%rsp),%r13
add    $0x1,%r13
cmp    %r12,%rbx
mov    0x20(%rsp),%rdx
je     12a2 <fold_dotstream+0x192>
test   %edx,%edx
mov    %r13,0x10(%rsp)
jle    1160 <fold_dotstream+0x50>
xor    %ebp,%ebp
jmp    11a1 <fold_dotstream+0x91>
nopl   0x0(%rax,%rax,1)
movb   $0x20,0x0(%r13)
add    $0x1,%rbp
add    %r12,%r13
cmp    %rbp,%r15
je     1160 <fold_dotstream+0x50>
lea    (%rbx,%rbp,1),%eax
test   $0x1,%al
jne    1190 <fold_dotstream+0x80>
mov    %ebx,%edi
mov    %ebp,%esi
mov    0x4(%rsp),%edx
mov    %r15d,%ecx
call   1030 <is_corner@plt>
test   %rax,%rax
je     11c4 <fold_dotstream+0xb4>
movb   $0x43,0x0(%r13)
jmp    1195 <fold_dotstream+0x85>
movslq %r14d,%r14
mov    0x18(%rsp),%rax
movzbl (%rax,%r14,1),%eax
mov    %al,0x0(%r13)
add    $0x1,%r14d
jmp    1195 <fold_dotstream+0x85>
movslq %esi,%rax
mov    %rax,0x30(%rsp)
test   %edx,%edx
jle    12ff <fold_dotstream+0x1ef>
lea    -0x1(%rdx),%eax
imul   %esi,%eax
xor    %r14d,%r14d
mov    0x8(%rsp),%rcx
mov    %rcx,0x10(%rsp)
xor    %r13d,%r13d
jmp    1236 <fold_dotstream+0x126>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
mov    0x4(%rsp),%esi
mov    0x2c(%rsp),%eax
sub    %esi,%eax
mov    0x10(%rsp),%rcx
add    0x30(%rsp),%rcx
mov    %rcx,0x10(%rsp)
cmp    %r15,%r14
je     1302 <fold_dotstream+0x1f2>
test   %esi,%esi
mov    %eax,0x2c(%rsp)
jle    1210 <fold_dotstream+0x100>
movslq %eax,%rbp
add    0x8(%rsp),%rbp
xor    %ebx,%ebx
jmp    125e <fold_dotstream+0x14e>
nopw   0x0(%rax,%rax,1)
movb   $0x20,0x0(%rbp,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r12
je     1210 <fold_dotstream+0x100>
lea    (%r14,%rbx,1),%eax
test   $0x1,%al
jne    1250 <fold_dotstream+0x140>
mov    %ebx,%edi
mov    %r14d,%esi
mov    %r12d,%edx
mov    0x20(%rsp),%rcx
call   1030 <is_corner@plt>
test   %rax,%rax
je     1288 <fold_dotstream+0x178>
mov    0x10(%rsp),%rax
movb   $0x43,(%rax,%rbx,1)
jmp    1255 <fold_dotstream+0x145>
movslq %r13d,%r13
mov    0x18(%rsp),%rax
movzbl (%rax,%r13,1),%eax
mov    %al,0x0(%rbp,%rbx,1)
add    $0x1,%r13d
jmp    1255 <fold_dotstream+0x145>
xor    %r14d,%r14d
movslq %r14d,%rax
mov    0x18(%rsp),%rbp
mov    0x0(%rbp,%rax,1),%cl
lea    -0x1(%rdx),%esi
mov    0x4(%rsp),%ebx
imul   %ebx,%esi
movslq %esi,%r8
mov    0x8(%rsp),%rdi
mov    %cl,-0x1(%r8,%rdi,1)
mov    0x1(%rbp,%rax,1),%cl
lea    -0x2(%rdx),%esi
imul   %ebx,%esi
movslq %esi,%rsi
mov    %cl,(%rdi,%rsi,1)
mov    0x2(%rbp,%rax,1),%cl
imul   %ebx,%edx
movslq %edx,%rsi
mov    %cl,-0x2(%rsi,%rdi,1)
mov    0x3(%rbp,%rax,1),%cl
mov    %cl,0x1(%r8,%rdi,1)
mov    0x4(%rbp,%rax,1),%cl
movslq %ebx,%rdx
mov    %cl,-0x1(%rdx,%rdi,1)
mov    0x5(%rbp,%rax,1),%al
mov    %al,(%rdi)
jmp    135a <fold_dotstream+0x24a>
xor    %r13d,%r13d
movslq %r13d,%rax
mov    0x18(%rsp),%rdi
mov    (%rdi,%rax,1),%cl
mov    0x8(%rsp),%rbp
mov    0x30(%rsp),%r8
mov    %cl,-0x2(%r8,%rbp,1)
mov    0x1(%rdi,%rax,1),%cl
mov    0x20(%rsp),%rbx
mov    %ebx,%edx
imul   %esi,%edx
movslq %edx,%rdx
mov    %cl,-0x2(%rdx,%rbp,1)
mov    0x2(%rdi,%rax,1),%cl
mov    %cl,-0x1(%rbp,%r8,2)
mov    0x3(%rdi,%rax,1),%cl
add    $0xffffffff,%ebx
imul   %esi,%ebx
movslq %ebx,%rdx
mov    %cl,-0x1(%rbp,%rdx,1)
mov    0x4(%rdi,%rax,1),%cl
mov    %cl,0x0(%rbp)
mov    0x5(%rdi,%rax,1),%al
mov    %al,0x0(%rbp,%rdx,1)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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