#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 */
char encode_char(char);
void encode_line(char *input, int offset, int octets, char *line) {
  int loffs = 0;
  line[loffs] = encode_char(octets);
  for (++loffs; octets > 0; offset += 3, octets -= 3) {
    char ch;
    if (octets >= 3) {
      ch = encode_char(input[offset] >> 2);
      line[loffs++] = ch;
      ch = encode_char((input[offset] << 4) | (input[offset + 1] >> 4));
      line[loffs++] = ch;
      ch = encode_char((input[offset + 1] << 2) | (input[offset + 2] >> 6));
      line[loffs++] = ch;
      ch = encode_char(input[offset + 2]);
      line[loffs++] = ch;
    } else {
      if (octets == 1) {
        ch = encode_char(input[offset] >> 2);
        line[loffs++] = ch;
        ch = encode_char(input[offset] << 4);
        line[loffs++] = ch;
        line[loffs++] = '=';
        line[loffs++] = '=';
      } else {
        if (octets == 2) {
          ch = encode_char((input[offset]) >> 2);
          line[loffs++] = ch;
          ch = encode_char((input[offset] << 4) | (input[offset + 1] >> 4));
          line[loffs++] = ch;
          ch = encode_char(input[offset + 1] << 2);
          line[loffs++] = ch;
          line[loffs++] = '=';
        }
      }
    }
  }
  line[loffs++] = '\n';
  line[loffs] = 0;
  return;
}


x86 assembly (clang, -O0):
<encode_line>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x10(%rbp)
jle    13f5 <encode_line+0x2e5>
cmpl   $0x3,-0x10(%rbp)
jl     125f <encode_line+0x14f>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sar    $0x2,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sar    $0x4,%ecx
or     %ecx,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sar    $0x6,%ecx
or     %ecx,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    13d9 <encode_line+0x2c9>
cmpl   $0x1,-0x10(%rbp)
jne    12fe <encode_line+0x1ee>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sar    $0x2,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
movb   $0x3d,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
movb   $0x3d,(%rax,%rcx,1)
jmp    13d4 <encode_line+0x2c4>
cmpl   $0x2,-0x10(%rbp)
jne    13cf <encode_line+0x2bf>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sar    $0x2,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sar    $0x4,%ecx
or     %ecx,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
movb   $0x3d,(%rax,%rcx,1)
jmp    13d4 <encode_line+0x2c4>
jmp    13d9 <encode_line+0x2c9>
jmp    13de <encode_line+0x2ce>
mov    -0xc(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x3,%eax
mov    %eax,-0x10(%rbp)
jmp    114e <encode_line+0x3e>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encode_line>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r12
mov    %edx,%r13d
mov    %esi,%r15d
mov    %rdi,%r14
movsbl %r13b,%edi
call   1030 <encode_char@plt>
mov    %al,(%r12)
test   %r13d,%r13d
jle    11c6 <encode_line+0xb6>
movslq %r15d,%rax
lea    (%rax,%r14,1),%rbp
add    $0x2,%rbp
mov    $0x5,%ebx
nopl   (%rax)
cmp    $0x2,%r13d
jbe    11cd <encode_line+0xbd>
movzbl -0x2(%rbp),%eax
sar    $0x2,%al
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x4(%r12,%rbx,1)
movzbl -0x2(%rbp),%eax
movzbl -0x1(%rbp),%ecx
shl    $0x4,%al
sar    $0x4,%cl
or     %al,%cl
movsbl %cl,%edi
call   1030 <encode_char@plt>
mov    %al,-0x3(%r12,%rbx,1)
movzbl -0x1(%rbp),%eax
movzbl 0x0(%rbp),%ecx
shl    $0x2,%al
sar    $0x6,%cl
or     %al,%cl
movsbl %cl,%edi
call   1030 <encode_char@plt>
mov    %al,-0x2(%r12,%rbx,1)
movsbl 0x0(%rbp),%edi
call   1030 <encode_char@plt>
mov    %al,-0x1(%r12,%rbx,1)
add    $0x3,%rbp
add    $0x4,%rbx
add    $0xfffffffd,%r13d
jne    1150 <encode_line+0x40>
add    $0xfffffffffffffffc,%rbx
jmp    122b <encode_line+0x11b>
mov    $0x1,%ebx
jmp    122b <encode_line+0x11b>
mov    -0x2(%rbp),%al
sar    $0x2,%al
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x4(%r12,%rbx,1)
mov    -0x2(%rbp),%al
shl    $0x4,%al
cmp    $0x1,%r13d
jne    11fd <encode_line+0xed>
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x3(%r12,%rbx,1)
mov    $0x3d,%al
jmp    1220 <encode_line+0x110>
mov    -0x1(%rbp),%cl
sar    $0x4,%cl
or     %al,%cl
movsbl %cl,%edi
call   1030 <encode_char@plt>
mov    %al,-0x3(%r12,%rbx,1)
mov    -0x1(%rbp),%al
shl    $0x2,%al
movsbl %al,%edi
call   1030 <encode_char@plt>
mov    %al,-0x2(%r12,%rbx,1)
movb   $0x3d,-0x1(%r12,%rbx,1)
mov    %ebx,%eax
movw   $0xa,(%r12,%rax,1)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @encode_line(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 i8
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i8* %3, i8** %8
store i32 0, i32* %9
%11 = load i32, i32* %7
%12 = trunc i32 %11 to i8
%13 = call signext i8 @encode_char(i8 signext %12)
%14 = load i8*, i8** %8
%15 = load i32, i32* %9
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i8, i8* %14, i64 %16
store i8 %13, i8* %17
%18 = load i32, i32* %9
%19 = add nsw i32 %18, 1
store i32 %19, i32* %9
br label %20
20: ; preds = %215, %4
%21 = load i32, i32* %7
%22 = icmp sgt i32 %21, 0
br i1 %22, label %23, label %220
23: ; preds = %20
%24 = load i32, i32* %7
%25 = icmp sge i32 %24, 3
br i1 %25, label %26, label %104
26: ; preds = %23
%27 = load i8*, i8** %5
%28 = load i32, i32* %6
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8, i8* %27, i64 %29
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = ashr i32 %32, 2
%34 = trunc i32 %33 to i8
%35 = call signext i8 @encode_char(i8 signext %34)
store i8 %35, i8* %10
%36 = load i8, i8* %10
%37 = load i8*, i8** %8
%38 = load i32, i32* %9
%39 = add nsw i32 %38, 1
store i32 %39, i32* %9
%40 = sext i32 %38 to i64
%41 = getelementptr inbounds i8, i8* %37, i64 %40
store i8 %36, i8* %41
%42 = load i8*, i8** %5
%43 = load i32, i32* %6
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = shl i32 %47, 4
%49 = load i8*, i8** %5
%50 = load i32, i32* %6
%51 = add nsw i32 %50, 1
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %49, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
%56 = ashr i32 %55, 4
%57 = or i32 %48, %56
%58 = trunc i32 %57 to i8
%59 = call signext i8 @encode_char(i8 signext %58)
store i8 %59, i8* %10
%60 = load i8, i8* %10
%61 = load i8*, i8** %8
%62 = load i32, i32* %9
%63 = add nsw i32 %62, 1
store i32 %63, i32* %9
%64 = sext i32 %62 to i64
%65 = getelementptr inbounds i8, i8* %61, i64 %64
store i8 %60, i8* %65
%66 = load i8*, i8** %5
%67 = load i32, i32* %6
%68 = add nsw i32 %67, 1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %66, i64 %69
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = shl i32 %72, 2
%74 = load i8*, i8** %5
%75 = load i32, i32* %6
%76 = add nsw i32 %75, 2
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %74, i64 %77
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = ashr i32 %80, 6
%82 = or i32 %73, %81
%83 = trunc i32 %82 to i8
%84 = call signext i8 @encode_char(i8 signext %83)
store i8 %84, i8* %10
%85 = load i8, i8* %10
%86 = load i8*, i8** %8
%87 = load i32, i32* %9
%88 = add nsw i32 %87, 1
store i32 %88, i32* %9
%89 = sext i32 %87 to i64
%90 = getelementptr inbounds i8, i8* %86, i64 %89
store i8 %85, i8* %90
%91 = load i8*, i8** %5
%92 = load i32, i32* %6
%93 = add nsw i32 %92, 2
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i8, i8* %91, i64 %94
%96 = load i8, i8* %95
%97 = call signext i8 @encode_char(i8 signext %96)
store i8 %97, i8* %10
%98 = load i8, i8* %10
%99 = load i8*, i8** %8
%100 = load i32, i32* %9
%101 = add nsw i32 %100, 1
store i32 %101, i32* %9
%102 = sext i32 %100 to i64
%103 = getelementptr inbounds i8, i8* %99, i64 %102
store i8 %98, i8* %103
br label %214
104: ; preds = %23
%105 = load i32, i32* %7
%106 = icmp eq i32 %105, 1
br i1 %106, label %107, label %148
107: ; preds = %104
%108 = load i8*, i8** %5
%109 = load i32, i32* %6
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %108, i64 %110
%112 = load i8, i8* %111
%113 = sext i8 %112 to i32
%114 = ashr i32 %113, 2
%115 = trunc i32 %114 to i8
%116 = call signext i8 @encode_char(i8 signext %115)
store i8 %116, i8* %10
%117 = load i8, i8* %10
%118 = load i8*, i8** %8
%119 = load i32, i32* %9
%120 = add nsw i32 %119, 1
store i32 %120, i32* %9
%121 = sext i32 %119 to i64
%122 = getelementptr inbounds i8, i8* %118, i64 %121
store i8 %117, i8* %122
%123 = load i8*, i8** %5
%124 = load i32, i32* %6
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
%127 = load i8, i8* %126
%128 = sext i8 %127 to i32
%129 = shl i32 %128, 4
%130 = trunc i32 %129 to i8
%131 = call signext i8 @encode_char(i8 signext %130)
store i8 %131, i8* %10
%132 = load i8, i8* %10
%133 = load i8*, i8** %8
%134 = load i32, i32* %9
%135 = add nsw i32 %134, 1
store i32 %135, i32* %9
%136 = sext i32 %134 to i64
%137 = getelementptr inbounds i8, i8* %133, i64 %136
store i8 %132, i8* %137
%138 = load i8*, i8** %8
%139 = load i32, i32* %9
%140 = add nsw i32 %139, 1
store i32 %140, i32* %9
%141 = sext i32 %139 to i64
%142 = getelementptr inbounds i8, i8* %138, i64 %141
store i8 61, i8* %142
%143 = load i8*, i8** %8
%144 = load i32, i32* %9
%145 = add nsw i32 %144, 1
store i32 %145, i32* %9
%146 = sext i32 %144 to i64
%147 = getelementptr inbounds i8, i8* %143, i64 %146
store i8 61, i8* %147
br label %213
148: ; preds = %104
%149 = load i32, i32* %7
%150 = icmp eq i32 %149, 2
br i1 %150, label %151, label %212
151: ; preds = %148
%152 = load i8*, i8** %5
%153 = load i32, i32* %6
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds i8, i8* %152, i64 %154
%156 = load i8, i8* %155
%157 = sext i8 %156 to i32
%158 = ashr i32 %157, 2
%159 = trunc i32 %158 to i8
%160 = call signext i8 @encode_char(i8 signext %159)
store i8 %160, i8* %10
%161 = load i8, i8* %10
%162 = load i8*, i8** %8
%163 = load i32, i32* %9
%164 = add nsw i32 %163, 1
store i32 %164, i32* %9
%165 = sext i32 %163 to i64
%166 = getelementptr inbounds i8, i8* %162, i64 %165
store i8 %161, i8* %166
%167 = load i8*, i8** %5
%168 = load i32, i32* %6
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i8, i8* %167, i64 %169
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = shl i32 %172, 4
%174 = load i8*, i8** %5
%175 = load i32, i32* %6
%176 = add nsw i32 %175, 1
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %174, i64 %177
%179 = load i8, i8* %178
%180 = sext i8 %179 to i32
%181 = ashr i32 %180, 4
%182 = or i32 %173, %181
%183 = trunc i32 %182 to i8
%184 = call signext i8 @encode_char(i8 signext %183)
store i8 %184, i8* %10
%185 = load i8, i8* %10
%186 = load i8*, i8** %8
%187 = load i32, i32* %9
%188 = add nsw i32 %187, 1
store i32 %188, i32* %9
%189 = sext i32 %187 to i64
%190 = getelementptr inbounds i8, i8* %186, i64 %189
store i8 %185, i8* %190
%191 = load i8*, i8** %5
%192 = load i32, i32* %6
%193 = add nsw i32 %192, 1
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i8, i8* %191, i64 %194
%196 = load i8, i8* %195
%197 = sext i8 %196 to i32
%198 = shl i32 %197, 2
%199 = trunc i32 %198 to i8
%200 = call signext i8 @encode_char(i8 signext %199)
store i8 %200, i8* %10
%201 = load i8, i8* %10
%202 = load i8*, i8** %8
%203 = load i32, i32* %9
%204 = add nsw i32 %203, 1
store i32 %204, i32* %9
%205 = sext i32 %203 to i64
%206 = getelementptr inbounds i8, i8* %202, i64 %205
store i8 %201, i8* %206
%207 = load i8*, i8** %8
%208 = load i32, i32* %9
%209 = add nsw i32 %208, 1
store i32 %209, i32* %9
%210 = sext i32 %208 to i64
%211 = getelementptr inbounds i8, i8* %207, i64 %210
store i8 61, i8* %211
br label %212
212: ; preds = %151, %148
br label %213
213: ; preds = %212, %107
br label %214
214: ; preds = %213, %26
br label %215
215: ; preds = %214
%216 = load i32, i32* %6
%217 = add nsw i32 %216, 3
store i32 %217, i32* %6
%218 = load i32, i32* %7
%219 = sub nsw i32 %218, 3
store i32 %219, i32* %7
br label %20
220: ; preds = %20
%221 = load i8*, i8** %8
%222 = load i32, i32* %9
%223 = add nsw i32 %222, 1
store i32 %223, i32* %9
%224 = sext i32 %222 to i64
%225 = getelementptr inbounds i8, i8* %221, i64 %224
store i8 10, i8* %225
%226 = load i8*, i8** %8
%227 = load i32, i32* %9
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i8, i8* %226, i64 %228
store i8 0, i8* %229
ret void
}

LLVM IR (-O2):
define void @encode_line(i8* nocapture %0, i32 %1, i32 %2, i8* nocapture writeonly %3) {
%5 = trunc i32 %2 to i8
%6 = tail call signext i8 @encode_char(i8 signext %5)
store i8 %6, i8* %3
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %83
8: ; preds = %4
%9 = sext i32 %1 to i64
br label %10
10: ; preds = %8, %46
%11 = phi i64 [ %9, %8 ], [ %77, %46 ]
%12 = phi i64 [ 1, %8 ], [ %76, %46 ]
%13 = phi i32 [ %2, %8 ], [ %78, %46 ]
%14 = icmp ugt i32 %13, 2
br i1 %14, label %46, label %15
15: ; preds = %10
%16 = icmp eq i32 %13, 1
%17 = getelementptr inbounds i8, i8* %0, i64 %11
%18 = load i8, i8* %17
%19 = ashr i8 %18, 2
%20 = tail call signext i8 @encode_char(i8 signext %19)
%21 = add nuw nsw i64 %12, 1
%22 = getelementptr inbounds i8, i8* %3, i64 %12
store i8 %20, i8* %22
%23 = load i8, i8* %17
%24 = shl i8 %23, 4
br i1 %16, label %25, label %28
25: ; preds = %15
%26 = tail call signext i8 @encode_char(i8 signext %24)
%27 = getelementptr inbounds i8, i8* %3, i64 %21
store i8 %26, i8* %27
br label %39
28: ; preds = %15
%29 = add nsw i64 %11, 1
%30 = getelementptr inbounds i8, i8* %0, i64 %29
%31 = load i8, i8* %30
%32 = ashr i8 %31, 4
%33 = or i8 %32, %24
%34 = tail call signext i8 @encode_char(i8 signext %33)
%35 = getelementptr inbounds i8, i8* %3, i64 %21
store i8 %34, i8* %35
%36 = load i8, i8* %30
%37 = shl i8 %36, 2
%38 = tail call signext i8 @encode_char(i8 signext %37)
br label %39
39: ; preds = %25, %28
%40 = phi i8 [ 61, %25 ], [ %38, %28 ]
%41 = add nuw nsw i64 %12, 2
%42 = add nuw nsw i64 %12, 3
%43 = getelementptr inbounds i8, i8* %3, i64 %41
store i8 %40, i8* %43
%44 = getelementptr inbounds i8, i8* %3, i64 %42
store i8 61, i8* %44
%45 = add nuw nsw i64 %12, 4
br label %80
46: ; preds = %10
%47 = getelementptr inbounds i8, i8* %0, i64 %11
%48 = load i8, i8* %47
%49 = ashr i8 %48, 2
%50 = tail call signext i8 @encode_char(i8 signext %49)
%51 = add nuw nsw i64 %12, 1
%52 = getelementptr inbounds i8, i8* %3, i64 %12
store i8 %50, i8* %52
%53 = load i8, i8* %47
%54 = shl i8 %53, 4
%55 = add nsw i64 %11, 1
%56 = getelementptr inbounds i8, i8* %0, i64 %55
%57 = load i8, i8* %56
%58 = ashr i8 %57, 4
%59 = or i8 %58, %54
%60 = tail call signext i8 @encode_char(i8 signext %59)
%61 = add nuw nsw i64 %12, 2
%62 = getelementptr inbounds i8, i8* %3, i64 %51
store i8 %60, i8* %62
%63 = load i8, i8* %56
%64 = shl i8 %63, 2
%65 = add nsw i64 %11, 2
%66 = getelementptr inbounds i8, i8* %0, i64 %65
%67 = load i8, i8* %66
%68 = ashr i8 %67, 6
%69 = or i8 %68, %64
%70 = tail call signext i8 @encode_char(i8 signext %69)
%71 = add nuw nsw i64 %12, 3
%72 = getelementptr inbounds i8, i8* %3, i64 %61
store i8 %70, i8* %72
%73 = load i8, i8* %66
%74 = tail call signext i8 @encode_char(i8 signext %73)
%75 = getelementptr inbounds i8, i8* %3, i64 %71
store i8 %74, i8* %75
%76 = add nuw nsw i64 %12, 4
%77 = add nsw i64 %11, 3
%78 = add nsw i32 %13, -3
%79 = icmp eq i32 %13, 3
br i1 %79, label %80, label %10
80: ; preds = %46, %39
%81 = phi i64 [ %45, %39 ], [ %76, %46 ]
%82 = trunc i64 %81 to i32
br label %83
83: ; preds = %80, %4
%84 = phi i32 [ 1, %4 ], [ %82, %80 ]
%85 = add nuw nsw i32 %84, 1
%86 = zext i32 %84 to i64
%87 = getelementptr inbounds i8, i8* %3, i64 %86
store i8 10, i8* %87
%88 = zext i32 %85 to i64
%89 = getelementptr inbounds i8, i8* %3, i64 %88
store i8 0, i8* %89
ret void
}