void split_to_lines(const unsigned char *str, char ***plns, int ws_mode) {
  const unsigned char *s, *q, *r;
  char **lns;
  int lcnt, i;
  if (!str || !*str) {
    *plns = 0;
    return;
  }
  for (s = str, lcnt = 0; *s; ++s)
    if (*s == '\n')
      lcnt++;
  if (s[-1] != '\n')
    lcnt++;
  ((lns) = (typeof(lns))xcalloc((lcnt + 1), sizeof((lns)[0])));
  for (s = str, i = 0; *s; s = q, ++i) {
    q = s;
    while (*q && *q != '\n')
      ++q;
    r = q;
    if (*q == '\n')
      ++q;
    while (r > s && isspace(r[-1]))
      --r;
    if (ws_mode == 2) {
      while (s < r && isspace(*s))
        ++s;
    }
    if (ws_mode == 1 && s < r && !isspace(*s)) {
      lns[i] = (unsigned char *)xmalloc(r - s + 2);
      lns[i][0] = ' ';
      memcpy(lns[i] + 1, s, r - s);
      lns[i][r - s + 1] = 0;
    } else {
      lns[i] = (unsigned char *)xmalloc(r - s + 1);
      memcpy(lns[i], s, r - s);
      lns[i][r - s] = 0;
    }
  }
  while (i > 0 && !lns[i - 1][0]) {
    --i;
    xfree(lns[i]);
    lns[i] = 0;
  }
  *plns = lns;
}


x86 assembly (clang, -O0):
<split_to_lines>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     117b <split_to_lines+0x2b>
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
jne    118b <split_to_lines+0x3b>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
jmp    14df <split_to_lines+0x38f>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     11d6 <split_to_lines+0x86>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xa,%eax
jne    11c0 <split_to_lines+0x70>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c5 <split_to_lines+0x75>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    119a <split_to_lines+0x4a>
mov    -0x20(%rbp),%rax
movzbl -0x1(%rax),%eax
cmp    $0xa,%eax
je     11f0 <split_to_lines+0xa0>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1070 <xcalloc@plt>
cltq
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1463 <split_to_lines+0x313>
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x41(%rbp)
je     1251 <split_to_lines+0x101>
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    1261 <split_to_lines+0x111>
jmp    1272 <split_to_lines+0x122>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    122c <split_to_lines+0xdc>
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xa,%eax
jne    1296 <split_to_lines+0x146>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    129b <split_to_lines+0x14b>
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x42(%rbp)
jbe    12c4 <split_to_lines+0x174>
mov    -0x30(%rbp),%rax
movzbl -0x1(%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
test   $0x1,%al
jne    12d4 <split_to_lines+0x184>
jmp    12e5 <split_to_lines+0x195>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    129b <split_to_lines+0x14b>
cmpl   $0x2,-0x14(%rbp)
jne    1342 <split_to_lines+0x1f2>
jmp    12f4 <split_to_lines+0x1a4>
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x30(%rbp),%rcx
mov    %al,-0x43(%rbp)
jae    131c <split_to_lines+0x1cc>
mov    -0x20(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%eax
setne  %al
mov    %al,-0x43(%rbp)
mov    -0x43(%rbp),%al
test   $0x1,%al
jne    132c <split_to_lines+0x1dc>
jmp    133d <split_to_lines+0x1ed>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12f4 <split_to_lines+0x1a4>
jmp    1342 <split_to_lines+0x1f2>
cmpl   $0x1,-0x14(%rbp)
jne    13e8 <split_to_lines+0x298>
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    13e8 <split_to_lines+0x298>
mov    -0x20(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%eax
jne    13e8 <split_to_lines+0x298>
mov    -0x30(%rbp),%rdi
mov    -0x20(%rbp),%rax
sub    %rax,%rdi
add    $0x2,%rdi
mov    $0x0,%al
call   1040 <xmalloc@plt>
movslq %eax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movb   $0x20,(%rax)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
add    $0x1,%rdi
mov    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
sub    %rax,%rdx
call   1060 <memcpy@plt>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
sub    %rdx,%rcx
movb   $0x0,0x1(%rax,%rcx,1)
jmp    1448 <split_to_lines+0x2f8>
mov    -0x30(%rbp),%rdi
mov    -0x20(%rbp),%rax
sub    %rax,%rdi
add    $0x1,%rdi
mov    $0x0,%al
call   1040 <xmalloc@plt>
movslq %eax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x20(%rbp),%rax
sub    %rax,%rdx
call   1060 <memcpy@plt>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
sub    %rdx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    144d <split_to_lines+0x2fd>
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1217 <split_to_lines+0xc7>
jmp    1468 <split_to_lines+0x318>
xor    %eax,%eax
cmpl   $0x0,-0x40(%rbp)
mov    %al,-0x44(%rbp)
jle    1493 <split_to_lines+0x343>
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
cmpb   $0x0,(%rax)
setne  %al
xor    $0xff,%al
mov    %al,-0x44(%rbp)
mov    -0x44(%rbp),%al
test   $0x1,%al
jne    14a3 <split_to_lines+0x353>
jmp    14d4 <split_to_lines+0x384>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    $0x0,%al
call   1030 <xfree@plt>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
jmp    1468 <split_to_lines+0x318>
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<split_to_lines>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edx,0x1c(%rsp)
mov    %rsi,%r14
test   %rdi,%rdi
je     1372 <split_to_lines+0x222>
mov    %rdi,%rbx
mov    (%rdi),%cl
xor    %r13d,%r13d
test   %cl,%cl
je     13be <split_to_lines+0x26e>
lea    0x1(%rbx),%rax
jmp    119b <split_to_lines+0x4b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13d
movzbl (%rax),%ecx
add    $0x1,%rax
cmp    $0xa,%cl
je     1190 <split_to_lines+0x40>
test   %cl,%cl
jne    1194 <split_to_lines+0x44>
xor    %ecx,%ecx
cmpb   $0xa,-0x2(%rax)
setne  %cl
lea    (%rcx,%r13,1),%edi
add    $0x1,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1070 <xcalloc@plt>
movslq %eax,%r13
mov    (%rbx),%r15b
test   %r15b,%r15b
je     13be <split_to_lines+0x26e>
mov    %r14,0x20(%rsp)
mov    $0x1,%eax
xor    %r14d,%r14d
mov    %r13,0x28(%rsp)
jmp    1237 <split_to_lines+0xe7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    %r12,%rbp
lea    0x1(%rbp),%rdi
xor    %eax,%eax
call   1040 <xmalloc@plt>
movslq %eax,%rdi
mov    0x28(%rsp),%r13
mov    %rdi,0x0(%r13,%r14,8)
mov    %r12,%rsi
mov    %rbp,%rdx
call   1060 <memcpy@plt>
add    0x0(%r13,%r14,8),%rbp
movb   $0x0,0x0(%rbp)
add    $0x1,%r14
mov    (%rbx),%r15b
mov    0x30(%rsp),%rcx
lea    0x1(%rcx),%eax
test   %r15b,%r15b
je     1377 <split_to_lines+0x227>
mov    %rbx,%r12
mov    %rax,0x30(%rsp)
mov    $0xffffffffffffffff,%rcx
mov    %rbx,%rbp
mov    %r15d,%eax
test   %al,%al
je     1268 <split_to_lines+0x118>
cmp    $0xa,%al
je     1268 <split_to_lines+0x118>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
add    $0x1,%rbp
add    $0x1,%rcx
test   %al,%al
jne    1250 <split_to_lines+0x100>
mov    %r14,0x8(%rsp)
xor    %edx,%edx
cmp    $0xa,%al
sete   %dl
add    %rbx,%rdx
mov    %rdx,0x10(%rsp)
nopl   0x0(%rax)
mov    %rbx,%r13
cmp    %r12,%rbx
jbe    1300 <split_to_lines+0x1b0>
mov    %rcx,%r14
lea    -0x1(%r13),%rbx
movzbl -0x1(%r13),%edi
call   1050 <isspace@plt>
add    $0xffffffffffffffff,%rbp
lea    -0x1(%r14),%rcx
test   %eax,%eax
jne    1280 <split_to_lines+0x130>
add    $0x1,%rbp
cmpl   $0x2,0x1c(%rsp)
jne    1300 <split_to_lines+0x1b0>
cmp    %r12,%r13
jbe    1300 <split_to_lines+0x1b0>
movzbl %r15b,%edi
call   1050 <isspace@plt>
test   %eax,%eax
je     1300 <split_to_lines+0x1b0>
add    $0x1,%rbx
cs nopw 0x0(%rax,%rax,1)
test   %r14,%r14
je     12ee <split_to_lines+0x19e>
movzbl 0x1(%r12),%edi
add    $0x1,%r12
call   1050 <isspace@plt>
add    $0xffffffffffffffff,%r14
test   %eax,%eax
jne    12d0 <split_to_lines+0x180>
jmp    1300 <split_to_lines+0x1b0>
mov    %rbx,%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rbx
mov    0x8(%rsp),%r14
cmpl   $0x1,0x1c(%rsp)
jne    11f0 <split_to_lines+0xa0>
cmp    %r13,%r12
jae    11f0 <split_to_lines+0xa0>
movzbl (%r12),%edi
call   1050 <isspace@plt>
test   %eax,%eax
jne    11f0 <split_to_lines+0xa0>
sub    %r12,%rbp
lea    0x2(%rbp),%rdi
xor    %eax,%eax
call   1040 <xmalloc@plt>
cltq
mov    0x28(%rsp),%r13
mov    %rax,0x0(%r13,%r14,8)
movb   $0x20,(%rax)
mov    0x0(%r13,%r14,8),%rdi
add    $0x1,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
call   1060 <memcpy@plt>
mov    0x0(%r13,%r14,8),%rax
add    %rax,%rbp
add    $0x1,%rbp
jmp    121b <split_to_lines+0xcb>
xor    %r13d,%r13d
jmp    13be <split_to_lines+0x26e>
test   %r14d,%r14d
jle    13b9 <split_to_lines+0x269>
mov    %ecx,%ebx
add    $0x1,%rbx
mov    0x20(%rsp),%r14
nopw   0x0(%rax,%rax,1)
lea    -0x2(%rbx),%ebp
mov    0x0(%r13,%rbp,8),%rdi
cmpb   $0x0,(%rdi)
jne    13be <split_to_lines+0x26e>
xor    %eax,%eax
call   1030 <xfree@plt>
movq   $0x0,0x0(%r13,%rbp,8)
add    $0xffffffffffffffff,%rbx
cmp    $0x1,%rbx
ja     1390 <split_to_lines+0x240>
jmp    13be <split_to_lines+0x26e>
mov    0x20(%rsp),%r14
mov    %r13,(%r14)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @split_to_lines(i8* %0, i8*** nocapture writeonly %1, i32 %2) {
%4 = icmp eq i8* %0, null
br i1 %4, label %131, label %5
5: ; preds = %3
%6 = load i8, i8* %0
%7 = icmp eq i8 %6, 0
br i1 %7, label %131, label %8
8: ; preds = %5, %14
%9 = phi i8 [ %17, %14 ], [ %6, %5 ]
%10 = phi i8* [ %16, %14 ], [ %0, %5 ]
%11 = phi i32 [ %15, %14 ], [ 0, %5 ]
switch i8 %9, label %14 [
i8 0, label %18
i8 10, label %12
]
12: ; preds = %8
%13 = add nsw i32 %11, 1
br label %14
14: ; preds = %8, %12
%15 = phi i32 [ %13, %12 ], [ %11, %8 ]
%16 = getelementptr inbounds i8, i8* %10, i64 1
%17 = load i8, i8* %16
br label %8
18: ; preds = %8
%19 = getelementptr inbounds i8, i8* %10, i64 -1
%20 = load i8, i8* %19
%21 = icmp ne i8 %20, 10
%22 = zext i1 %21 to i32
%23 = add i32 %11, 1
%24 = add i32 %23, %22
%25 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @xcalloc to i32 (i32, i64, ...)*)(i32 %24, i64 8)
%26 = sext i32 %25 to i64
%27 = inttoptr i64 %26 to i8**
%28 = load i8, i8* %0
%29 = icmp eq i8 %28, 0
br i1 %29, label %131, label %30
30: ; preds = %18
%31 = icmp eq i32 %2, 2
%32 = icmp eq i32 %2, 1
br label %33
33: ; preds = %30, %115
%34 = phi i64 [ 0, %30 ], [ %117, %115 ]
%35 = phi i8 [ %28, %30 ], [ %118, %115 ]
%36 = phi i8* [ %0, %30 ], [ %52, %115 ]
%37 = ptrtoint i8* %36 to i64
br label %43
38: ; preds = %115
%39 = trunc i64 %117 to i32
%40 = icmp sgt i32 %39, 0
br i1 %40, label %41, label %131
41: ; preds = %38
%42 = and i64 %117, 4294967295
br label %120
43: ; preds = %33, %46
%44 = phi i8 [ %48, %46 ], [ %35, %33 ]
%45 = phi i8* [ %47, %46 ], [ %36, %33 ]
switch i8 %44, label %46 [
i8 0, label %49
i8 10, label %49
]
46: ; preds = %43
%47 = getelementptr inbounds i8, i8* %45, i64 1
%48 = load i8, i8* %47
br label %43
49: ; preds = %43, %43
%50 = icmp eq i8 %44, 10
%51 = zext i1 %50 to i64
%52 = getelementptr i8, i8* %45, i64 %51
br label %53
53: ; preds = %58, %49
%54 = phi i8* [ %45, %49 ], [ %59, %58 ]
%55 = icmp ugt i8* %54, %36
br i1 %55, label %58, label %56
56: ; preds = %53
%57 = ptrtoint i8* %54 to i64
br label %82
58: ; preds = %53
%59 = getelementptr inbounds i8, i8* %54, i64 -1
%60 = load i8, i8* %59
%61 = zext i8 %60 to i32
%62 = tail call i32 @isspace(i32 %61)
%63 = icmp eq i32 %62, 0
br i1 %63, label %64, label %53
64: ; preds = %58
%65 = ptrtoint i8* %54 to i64
%66 = select i1 %31, i1 %55, i1 false
br i1 %66, label %67, label %82
67: ; preds = %64
%68 = sub i64 %65, %37
%69 = getelementptr i8, i8* %36, i64 %68
%70 = zext i8 %35 to i32
%71 = tail call i32 @isspace(i32 %70)
%72 = icmp eq i32 %71, 0
br i1 %72, label %82, label %73
73: ; preds = %67, %77
%74 = phi i8* [ %75, %77 ], [ %36, %67 ]
%75 = getelementptr inbounds i8, i8* %74, i64 1
%76 = icmp eq i8* %75, %69
br i1 %76, label %82, label %77
77: ; preds = %73
%78 = load i8, i8* %75
%79 = zext i8 %78 to i32
%80 = tail call i32 @isspace(i32 %79)
%81 = icmp eq i32 %80, 0
br i1 %81, label %82, label %73
82: ; preds = %77, %73, %67, %56, %64
%83 = phi i64 [ %65, %64 ], [ %57, %56 ], [ %65, %67 ], [ %65, %73 ], [ %65, %77 ]
%84 = phi i8* [ %36, %64 ], [ %36, %56 ], [ %36, %67 ], [ %75, %77 ], [ %69, %73 ]
%85 = icmp ult i8* %84, %54
%86 = select i1 %32, i1 %85, i1 false
br i1 %86, label %87, label %105
87: ; preds = %82
%88 = load i8, i8* %84
%89 = zext i8 %88 to i32
%90 = tail call i32 @isspace(i32 %89)
%91 = icmp eq i32 %90, 0
br i1 %91, label %92, label %105
92: ; preds = %87
%93 = ptrtoint i8* %84 to i64
%94 = sub i64 %83, %93
%95 = add nsw i64 %94, 2
%96 = tail call i32 (i64, ...) bitcast (i32 (...)* @xmalloc to i32 (i64, ...)*)(i64 %95)
%97 = sext i32 %96 to i64
%98 = inttoptr i64 %97 to i8*
%99 = getelementptr inbounds i8*, i8** %27, i64 %34
store i8* %98, i8** %99
store i8 32, i8* %98
%100 = load i8*, i8** %99
%101 = getelementptr inbounds i8, i8* %100, i64 1
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %101, i8* align 1 %84, i64 %94, i1 false)
%102 = load i8*, i8** %99
%103 = add nsw i64 %94, 1
%104 = getelementptr inbounds i8, i8* %102, i64 %103
br label %115
105: ; preds = %87, %82
%106 = ptrtoint i8* %84 to i64
%107 = sub i64 %83, %106
%108 = add nsw i64 %107, 1
%109 = tail call i32 (i64, ...) bitcast (i32 (...)* @xmalloc to i32 (i64, ...)*)(i64 %108)
%110 = sext i32 %109 to i64
%111 = inttoptr i64 %110 to i8*
%112 = getelementptr inbounds i8*, i8** %27, i64 %34
store i8* %111, i8** %112
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %111, i8* align 1 %84, i64 %107, i1 false)
%113 = load i8*, i8** %112
%114 = getelementptr inbounds i8, i8* %113, i64 %107
br label %115
115: ; preds = %92, %105
%116 = phi i8* [ %104, %92 ], [ %114, %105 ]
store i8 0, i8* %116
%117 = add nuw i64 %34, 1
%118 = load i8, i8* %52
%119 = icmp eq i8 %118, 0
br i1 %119, label %38, label %33
120: ; preds = %41, %128
%121 = phi i64 [ %42, %41 ], [ %122, %128 ]
%122 = add nsw i64 %121, -1
%123 = and i64 %122, 4294967295
%124 = getelementptr inbounds i8*, i8** %27, i64 %123
%125 = load i8*, i8** %124
%126 = load i8, i8* %125
%127 = icmp eq i8 %126, 0
br i1 %127, label %128, label %131
128: ; preds = %120
%129 = tail call i32 (i8*, ...) bitcast (i32 (...)* @xfree to i32 (i8*, ...)*)(i8* %125)
store i8* null, i8** %124
%130 = icmp ugt i64 %121, 1
br i1 %130, label %120, label %131
131: ; preds = %128, %120, %18, %38, %3, %5
%132 = phi i8** [ null, %5 ], [ null, %3 ], [ %27, %38 ], [ %27, %18 ], [ %27, %120 ], [ %27, %128 ]
store i8** %132, i8*** %1
ret void
}