#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*/ free(char *);
scalar_t__ malloc(int);
int strlen(char *);
char *SelfWithRowColumnConvert(char *buffer) {
  char *matrix = (char *)malloc((strlen(buffer) + 1) * 2 * sizeof(char));
  for (int row = 0; row < 4; row++) {
    for (int col = 0; col < 5 * 2; col++) {
      if ((buffer[row * 5 + col] == '\n') || (buffer[row * 5 + col] == '\0')) {
        matrix[row * 5 * 2 + col] = '|';
        col++;
        for (int i = 0; i < 5 - 1; i++, col++) {
          matrix[row * 5 * 2 + col] = buffer[i * 5 + row];
        }
        matrix[row * 5 * 2 + col] = '\n';
        break;
      }
      matrix[row * 5 * 2 + col] = buffer[row * 5 + col];
    }
  }
  matrix[4 * 5 * 2 - 1] = '\0';
  free(buffer);
  return matrix;
}


x86 assembly (clang, -O0):
<SelfWithRowColumnConvert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
add    $0x1,%eax
shl    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    127f <SelfWithRowColumnConvert+0x14f>
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    126c <SelfWithRowColumnConvert+0x13c>
mov    -0x8(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     11b4 <SelfWithRowColumnConvert+0x84>
mov    -0x8(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1239 <SelfWithRowColumnConvert+0x109>
mov    -0x10(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
shl    $0x1,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movb   $0x7c,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jge    121f <SelfWithRowColumnConvert+0xef>
mov    -0x8(%rbp),%rax
imul   $0x5,-0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
shl    $0x1,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d9 <SelfWithRowColumnConvert+0xa9>
mov    -0x10(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
shl    $0x1,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
jmp    126c <SelfWithRowColumnConvert+0x13c>
mov    -0x8(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
imul   $0x5,-0x14(%rbp),%ecx
shl    $0x1,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1174 <SelfWithRowColumnConvert+0x44>
jmp    1271 <SelfWithRowColumnConvert+0x141>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1163 <SelfWithRowColumnConvert+0x33>
mov    -0x10(%rbp),%rax
movb   $0x0,0x27(%rax)
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x10(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SelfWithRowColumnConvert>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%r15
call   1040 <strlen@plt>
lea    (%rax,%rax,1),%edi
add    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    $0x5,%eax
xor    %ecx,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r15,%rcx,1),%ebx
test   %bl,%bl
je     12a0 <SelfWithRowColumnConvert+0x170>
mov    $0x0,%esi
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,(%r14,%rcx,2)
movzbl 0x1(%r15,%rcx,1),%ebx
mov    $0x1,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x1(%r14,%rcx,2)
movzbl 0x2(%r15,%rcx,1),%ebx
mov    $0x2,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x2(%r14,%rcx,2)
movzbl 0x3(%r15,%rcx,1),%ebx
mov    $0x3,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x3(%r14,%rcx,2)
movzbl 0x4(%r15,%rcx,1),%ebx
mov    $0x4,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x4(%r14,%rcx,2)
movzbl 0x5(%r15,%rcx,1),%ebx
mov    $0x5,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x5(%r14,%rcx,2)
movzbl 0x6(%r15,%rcx,1),%ebx
mov    $0x6,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x6(%r14,%rcx,2)
movzbl 0x7(%r15,%rcx,1),%ebx
mov    $0x7,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x7(%r14,%rcx,2)
movzbl 0x8(%r15,%rcx,1),%ebx
mov    $0x8,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
mov    %bl,0x8(%r14,%rcx,2)
movzbl 0x9(%r15,%rcx,1),%ebx
mov    $0x9,%esi
test   %bl,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
cmp    $0xa,%bl
je     12a2 <SelfWithRowColumnConvert+0x172>
lea    (%rdx,%rdx,1),%rsi
lea    (%rsi,%rsi,4),%rsi
add    $0x9,%rsi
jmp    12d6 <SelfWithRowColumnConvert+0x1a6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
lea    (%rsi,%r14,1),%rdi
movb   $0x7c,(%rdi,%rcx,2)
movzbl (%r15,%rdx,1),%ebx
mov    %bl,0x1(%rdi,%rcx,2)
movzbl 0x5(%r15,%rdx,1),%ebx
mov    %bl,0x2(%rdi,%rcx,2)
movzbl 0xa(%r15,%rdx,1),%ebx
mov    %bl,0x3(%rdi,%rcx,2)
movzbl 0xf(%r15,%rdx,1),%ebx
mov    %bl,0x4(%rdi,%rcx,2)
add    %rax,%rsi
mov    $0xa,%bl
mov    %bl,(%r14,%rsi,1)
add    $0x1,%rdx
add    $0x5,%rcx
add    $0xa,%rax
cmp    $0x14,%rcx
jne    1160 <SelfWithRowColumnConvert+0x30>
movb   $0x0,0x27(%r14)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rax
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define i8* @SelfWithRowColumnConvert(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = shl i32 %2, 1
%4 = add i32 %3, 2
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i8*
br label %7
7: ; preds = %1, %100
%8 = phi i64 [ 0, %1 ], [ %104, %100 ]
%9 = mul nuw nsw i64 %8, 5
%10 = mul nuw nsw i64 %8, 10
%11 = getelementptr inbounds i8, i8* %0, i64 %9
%12 = load i8, i8* %11
switch i8 %12, label %45 [
i8 10, label %16
i8 0, label %16
]
13: ; preds = %100
%14 = getelementptr inbounds i8, i8* %6, i64 39
store i8 0, i8* %14
%15 = tail call i32 @free(i8* %0)
ret i8* %6
16: ; preds = %92, %92, %86, %86, %80, %80, %74, %74, %68, %68, %62, %62, %56, %56, %50, %50, %45, %45, %7, %7
%17 = phi i64 [ 0, %7 ], [ 0, %7 ], [ 1, %45 ], [ 1, %45 ], [ 2, %50 ], [ 2, %50 ], [ 3, %56 ], [ 3, %56 ], [ 4, %62 ], [ 4, %62 ], [ 5, %68 ], [ 5, %68 ], [ 6, %74 ], [ 6, %74 ], [ 7, %80 ], [ 7, %80 ], [ 8, %86 ], [ 8, %86 ], [ 9, %92 ], [ 9, %92 ]
%18 = add nuw nsw i64 %17, %10
%19 = getelementptr inbounds i8, i8* %6, i64 %18
store i8 124, i8* %19
%20 = add nuw nsw i64 %17, 1
%21 = getelementptr inbounds i8, i8* %0, i64 %8
%22 = load i8, i8* %21
%23 = add nuw nsw i64 %20, %10
%24 = getelementptr inbounds i8, i8* %6, i64 %23
store i8 %22, i8* %24
%25 = add nuw nsw i64 %17, 2
%26 = add nuw nsw i64 %8, 5
%27 = getelementptr inbounds i8, i8* %0, i64 %26
%28 = load i8, i8* %27
%29 = add nuw nsw i64 %25, %10
%30 = getelementptr inbounds i8, i8* %6, i64 %29
store i8 %28, i8* %30
%31 = add nuw nsw i64 %17, 3
%32 = add nuw nsw i64 %8, 10
%33 = getelementptr inbounds i8, i8* %0, i64 %32
%34 = load i8, i8* %33
%35 = add nuw nsw i64 %31, %10
%36 = getelementptr inbounds i8, i8* %6, i64 %35
store i8 %34, i8* %36
%37 = add nuw nsw i64 %17, 4
%38 = add nuw nsw i64 %8, 15
%39 = getelementptr inbounds i8, i8* %0, i64 %38
%40 = load i8, i8* %39
%41 = add nuw nsw i64 %37, %10
%42 = getelementptr inbounds i8, i8* %6, i64 %41
store i8 %40, i8* %42
%43 = add nuw nsw i64 %17, 5
%44 = add nuw nsw i64 %43, %10
br label %100
45: ; preds = %7
%46 = getelementptr inbounds i8, i8* %6, i64 %10
store i8 %12, i8* %46
%47 = add nuw nsw i64 %9, 1
%48 = getelementptr inbounds i8, i8* %0, i64 %47
%49 = load i8, i8* %48
switch i8 %49, label %50 [
i8 10, label %16
i8 0, label %16
]
50: ; preds = %45
%51 = or i64 %10, 1
%52 = getelementptr inbounds i8, i8* %6, i64 %51
store i8 %49, i8* %52
%53 = add nuw nsw i64 %9, 2
%54 = getelementptr inbounds i8, i8* %0, i64 %53
%55 = load i8, i8* %54
switch i8 %55, label %56 [
i8 10, label %16
i8 0, label %16
]
56: ; preds = %50
%57 = add nuw nsw i64 %10, 2
%58 = getelementptr inbounds i8, i8* %6, i64 %57
store i8 %55, i8* %58
%59 = add nuw nsw i64 %9, 3
%60 = getelementptr inbounds i8, i8* %0, i64 %59
%61 = load i8, i8* %60
switch i8 %61, label %62 [
i8 10, label %16
i8 0, label %16
]
62: ; preds = %56
%63 = add nuw nsw i64 %10, 3
%64 = getelementptr inbounds i8, i8* %6, i64 %63
store i8 %61, i8* %64
%65 = add nuw nsw i64 %9, 4
%66 = getelementptr inbounds i8, i8* %0, i64 %65
%67 = load i8, i8* %66
switch i8 %67, label %68 [
i8 10, label %16
i8 0, label %16
]
68: ; preds = %62
%69 = add nuw nsw i64 %10, 4
%70 = getelementptr inbounds i8, i8* %6, i64 %69
store i8 %67, i8* %70
%71 = add nuw nsw i64 %9, 5
%72 = getelementptr inbounds i8, i8* %0, i64 %71
%73 = load i8, i8* %72
switch i8 %73, label %74 [
i8 10, label %16
i8 0, label %16
]
74: ; preds = %68
%75 = add nuw nsw i64 %10, 5
%76 = getelementptr inbounds i8, i8* %6, i64 %75
store i8 %73, i8* %76
%77 = add nuw nsw i64 %9, 6
%78 = getelementptr inbounds i8, i8* %0, i64 %77
%79 = load i8, i8* %78
switch i8 %79, label %80 [
i8 10, label %16
i8 0, label %16
]
80: ; preds = %74
%81 = add nuw nsw i64 %10, 6
%82 = getelementptr inbounds i8, i8* %6, i64 %81
store i8 %79, i8* %82
%83 = add nuw nsw i64 %9, 7
%84 = getelementptr inbounds i8, i8* %0, i64 %83
%85 = load i8, i8* %84
switch i8 %85, label %86 [
i8 10, label %16
i8 0, label %16
]
86: ; preds = %80
%87 = add nuw nsw i64 %10, 7
%88 = getelementptr inbounds i8, i8* %6, i64 %87
store i8 %85, i8* %88
%89 = add nuw nsw i64 %9, 8
%90 = getelementptr inbounds i8, i8* %0, i64 %89
%91 = load i8, i8* %90
switch i8 %91, label %92 [
i8 10, label %16
i8 0, label %16
]
92: ; preds = %86
%93 = add nuw nsw i64 %10, 8
%94 = getelementptr inbounds i8, i8* %6, i64 %93
store i8 %91, i8* %94
%95 = add nuw nsw i64 %9, 9
%96 = getelementptr inbounds i8, i8* %0, i64 %95
%97 = load i8, i8* %96
switch i8 %97, label %98 [
i8 10, label %16
i8 0, label %16
]
98: ; preds = %92
%99 = add nuw nsw i64 %10, 9
br label %100
100: ; preds = %98, %16
%101 = phi i64 [ %99, %98 ], [ %44, %16 ]
%102 = phi i8 [ %97, %98 ], [ 10, %16 ]
%103 = getelementptr inbounds i8, i8* %6, i64 %101
store i8 %102, i8* %103
%104 = add nuw nsw i64 %8, 1
%105 = icmp eq i64 %104, 4
br i1 %105, label %13, label %7
}