#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 */
typedef int /*<<< orphan*/ lines;

/* Variables and functions */
scalar_t__ alloca(size_t);
scalar_t__ isspace(unsigned char const);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char const *, size_t);
int /*<<< orphan*/ memset(unsigned char **, int /*<<< orphan*/, int);
size_t strlen(unsigned char const *);
unsigned char *xstrdup(unsigned char *);
unsigned char *get_nth_alternative(const unsigned char *txt, int n) {
  const unsigned char *s, *p;
  unsigned char *txt2;
  size_t txt_len, t_len;
  int line_max_count = 0, line_count = 0, i;
  unsigned char **lines = 0;
  unsigned char *t;
  if (!txt)
    return 0;
  txt_len = strlen(txt);
  txt2 = (unsigned char *)alloca(txt_len + 2);
  memcpy(txt2, txt, txt_len + 1);
  while (txt_len > 0 && isspace(txt2[txt_len - 1]))
    txt_len--;
  if (!txt_len)
    return 0;
  txt2[txt_len++] = '\n';
  txt2[txt_len] = 0;
  for (s = txt2; *s; s++)
    if (*s == '\n')
      line_max_count++;
  lines = (unsigned char **)alloca((line_max_count + 1) * sizeof(lines[0]));
  memset(lines, 0, (line_max_count + 1) * sizeof(lines[0]));
  s = txt2;
  while (*s) {
    while (*s != '\n' && isspace(*s))
      s++;
    if (*s == '#')
      while (*s != '\n')
        s++;
    if (*s == '\n') {
      s++;
      continue;
    }
    p = s;
    while (*s != '\n')
      s++;
    t_len = s - p;
    t = (unsigned char *)alloca(t_len + 1);
    memcpy(t, p, t_len);
    while (t_len > 0 && isspace(t[t_len - 1]))
      t_len--;
    t[t_len] = 0;
    lines[line_count++] = t;
  }
  for (i = 0; i + 1 != n && i < line_count; i++)
    ;
  if (i + 1 == n && i < line_count)
    return xstrdup(lines[i]);
  return 0;
}


x86 assembly (clang, -O0):
<get_nth_alternative>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movq   $0x0,-0x58(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    119d <get_nth_alternative+0x3d>
movq   $0x0,-0x8(%rbp)
jmp    14ec <get_nth_alternative+0x38c>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
add    $0x2,%rdi
call   1070 <alloca@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x38(%rbp),%rdx
add    $0x1,%rdx
call   1080 <memcpy@plt>
xor    %eax,%eax
cmpq   $0x0,-0x38(%rbp)
mov    %al,-0x61(%rbp)
jbe    11ff <get_nth_alternative+0x9f>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    120f <get_nth_alternative+0xaf>
jmp    1220 <get_nth_alternative+0xc0>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    11d0 <get_nth_alternative+0x70>
cmpq   $0x0,-0x38(%rbp)
jne    1238 <get_nth_alternative+0xd8>
movq   $0x0,-0x8(%rbp)
jmp    14ec <get_nth_alternative+0x38c>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movb   $0xa,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     129f <get_nth_alternative+0x13f>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xa,%eax
jne    1289 <get_nth_alternative+0x129>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    128e <get_nth_alternative+0x12e>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1263 <get_nth_alternative+0x103>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1070 <alloca@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x44(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1465 <get_nth_alternative+0x305>
jmp    12e8 <get_nth_alternative+0x188>
mov    -0x20(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x62(%rbp)
je     1313 <get_nth_alternative+0x1b3>
mov    -0x20(%rbp),%rax
movzbl (%rax),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
test   $0x1,%al
jne    1323 <get_nth_alternative+0x1c3>
jmp    1334 <get_nth_alternative+0x1d4>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12e8 <get_nth_alternative+0x188>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x23,%eax
jne    136f <get_nth_alternative+0x20f>
jmp    1349 <get_nth_alternative+0x1e9>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xa,%eax
je     136a <get_nth_alternative+0x20a>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1349 <get_nth_alternative+0x1e9>
jmp    136f <get_nth_alternative+0x20f>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xa,%eax
jne    1390 <get_nth_alternative+0x230>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12d6 <get_nth_alternative+0x176>
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xa,%eax
je     13b9 <get_nth_alternative+0x259>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1398 <get_nth_alternative+0x238>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
add    $0x1,%rdi
call   1070 <alloca@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1080 <memcpy@plt>
xor    %eax,%eax
cmpq   $0x0,-0x40(%rbp)
mov    %al,-0x63(%rbp)
jbe    1419 <get_nth_alternative+0x2b9>
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x63(%rbp)
mov    -0x63(%rbp),%al
test   $0x1,%al
jne    1429 <get_nth_alternative+0x2c9>
jmp    143a <get_nth_alternative+0x2da>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    13ea <get_nth_alternative+0x28a>
mov    -0x60(%rbp),%rax
mov    -0x40(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x60(%rbp),%rdx
mov    -0x58(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x48(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    12d6 <get_nth_alternative+0x176>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x64(%rbp)
je     148c <get_nth_alternative+0x32c>
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
setl   %al
mov    %al,-0x64(%rbp)
mov    -0x64(%rbp),%al
test   $0x1,%al
jne    149c <get_nth_alternative+0x33c>
jmp    14af <get_nth_alternative+0x34f>
jmp    14a1 <get_nth_alternative+0x341>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    146c <get_nth_alternative+0x30c>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
cmp    -0x14(%rbp),%eax
jne    14e4 <get_nth_alternative+0x384>
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    14e4 <get_nth_alternative+0x384>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <xstrdup@plt>
mov    %rax,-0x8(%rbp)
jmp    14ec <get_nth_alternative+0x38c>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_nth_alternative>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
test   %rdi,%rdi
je     148e <get_nth_alternative+0x32e>
mov    %esi,%r13d
mov    %rdi,%r12
call   1030 <strlen@plt>
mov    %rax,%r14
lea    0x2(%rax),%rdi
call   1070 <alloca@plt>
mov    %rax,%r15
mov    %r14,%rdx
add    $0x1,%rdx
mov    %rax,%rdi
mov    %r12,%rsi
call   1080 <memcpy@plt>
mov    %r14,%rbx
cs nopw 0x0(%rax,%rax,1)
sub    $0x1,%rbx
jb     148e <get_nth_alternative+0x32e>
movzbl -0x1(%r15,%r14,1),%edi
call   1060 <isspace@plt>
mov    %rbx,%r14
test   %rax,%rax
jne    11b0 <get_nth_alternative+0x50>
movw   $0xa,0x1(%r15,%rbx,1)
xor    %eax,%eax
mov    %r15,%rcx
jmp    11e7 <get_nth_alternative+0x87>
nopl   0x0(%rax)
add    $0x1,%eax
add    $0x1,%rcx
movzbl (%rcx),%edx
cmp    $0xa,%dl
je     11e0 <get_nth_alternative+0x80>
test   %dl,%dl
jne    11e3 <get_nth_alternative+0x83>
cltq
lea    0x8(,%rax,8),%r12
mov    %r12,%rdi
call   1070 <alloca@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
mov    %rax,%rdi
xor    %esi,%esi
mov    %r12d,%edx
call   1040 <memset@plt>
mov    (%r15),%al
mov    $0x0,%r14d
test   %al,%al
je     1333 <get_nth_alternative+0x1d3>
xor    %r14d,%r14d
mov    %rbx,0x8(%rsp)
jmp    1260 <get_nth_alternative+0x100>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15),%al
cmp    $0x23,%al
je     1290 <get_nth_alternative+0x130>
cmp    $0xa,%al
jne    12af <get_nth_alternative+0x14f>
nopl   0x0(%rax,%rax,1)
mov    0x1(%r15),%al
add    $0x1,%r15
test   %al,%al
je     132e <get_nth_alternative+0x1ce>
cmp    $0xa,%al
je     1250 <get_nth_alternative+0xf0>
mov    %r15,%rbx
nopw   0x0(%rax,%rax,1)
movzbl %al,%edi
call   1060 <isspace@plt>
test   %rax,%rax
je     1240 <get_nth_alternative+0xe0>
movzbl 0x1(%r15),%eax
add    $0x1,%r15
add    $0x1,%rbx
cmp    $0xa,%al
jne    1270 <get_nth_alternative+0x110>
jmp    1250 <get_nth_alternative+0xf0>
mov    %r15,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rax),%r15
cmpb   $0xa,0x1(%rax)
mov    %r15,%rax
jne    12a0 <get_nth_alternative+0x140>
jmp    1250 <get_nth_alternative+0xf0>
mov    %r13,0x10(%rsp)
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
cmpb   $0xa,0x1(%r15,%r12,1)
lea    0x1(%r12),%r12
jne    12c0 <get_nth_alternative+0x160>
lea    0x1(%r12),%rdi
call   1070 <alloca@plt>
mov    %rax,%r13
mov    %rax,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
call   1080 <memcpy@plt>
add    %r12,%r15
nopl   0x0(%rax,%rax,1)
mov    %r12,%rbx
sub    $0x1,%r12
jb     1309 <get_nth_alternative+0x1a9>
movzbl -0x1(%r13,%rbx,1),%edi
call   1060 <isspace@plt>
test   %rax,%rax
jne    12f0 <get_nth_alternative+0x190>
movb   $0x0,0x0(%r13,%rbx,1)
mov    0x8(%rsp),%rbx
mov    %r13,(%rbx,%r14,8)
add    $0x1,%r14
mov    (%r15),%al
test   %al,%al
mov    0x10(%rsp),%r13
jne    1260 <get_nth_alternative+0x100>
jmp    1333 <get_nth_alternative+0x1d3>
mov    0x8(%rsp),%rbx
lea    -0x1(%r13),%eax
test   %r14d,%r14d
mov    $0x0,%edx
cmovg  %r14d,%edx
cmp    %eax,%edx
cmovae %eax,%edx
add    $0x1,%edx
test   %eax,%eax
mov    $0x1,%ecx
cmovne %edx,%ecx
cmp    $0x10,%ecx
jb     1450 <get_nth_alternative+0x2f0>
mov    %ecx,%ebp
and    $0xfffffff0,%ebp
lea    -0x10(%rbp),%edi
mov    %edi,%esi
shr    $0x4,%esi
add    $0x1,%esi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x70,%edi
jae    13a1 <get_nth_alternative+0x241>
movdqa 0xc80(%rip),%xmm0
movdqa 0xc88(%rip),%xmm1
movdqa 0xc90(%rip),%xmm2
movdqa 0xc98(%rip),%xmm3
test   %edx,%edx
jne    13f5 <get_nth_alternative+0x295>
jmp    1419 <get_nth_alternative+0x2b9>
and    $0xfffffff8,%esi
movdqa 0xc54(%rip),%xmm0
movdqa 0xc5c(%rip),%xmm1
movdqa 0xc64(%rip),%xmm2
movdqa 0xc6c(%rip),%xmm3
movdqa 0xc74(%rip),%xmm5
nopl   0x0(%rax)
movdqa %xmm0,%xmm4
paddd  %xmm5,%xmm3
paddd  %xmm5,%xmm2
paddd  %xmm5,%xmm1
paddd  %xmm5,%xmm0
add    $0xfffffff8,%esi
jne    13d0 <get_nth_alternative+0x270>
paddd  0xc5f(%rip),%xmm4
test   %edx,%edx
je     1419 <get_nth_alternative+0x2b9>
movdqa 0xc63(%rip),%xmm5
nopl   (%rax)
movdqa %xmm0,%xmm4
paddd  %xmm5,%xmm3
paddd  %xmm5,%xmm2
paddd  %xmm5,%xmm1
paddd  %xmm5,%xmm0
add    $0xffffffff,%edx
jne    1400 <get_nth_alternative+0x2a0>
pshufd $0xff,%xmm4,%xmm0
movd   %xmm0,%edx
add    $0x1,%edx
cmp    %r13d,%edx
setne  %dl
cmp    %ebp,%ecx
jne    1450 <get_nth_alternative+0x2f0>
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm0
pcmpgtd %xmm4,%xmm0
add    $0xffffffff,%ebp
pextrw $0x6,%xmm0,%esi
mov    %ebp,%ecx
test   %dl,%dl
je     146f <get_nth_alternative+0x30f>
jmp    148e <get_nth_alternative+0x32e>
nopl   (%rax)
lea    0x1(%rbp),%ecx
cmp    %r14d,%ebp
setl   %sil
cmp    %ebp,%eax
setne  %dl
je     1468 <get_nth_alternative+0x308>
cmp    %r14d,%ebp
mov    %ecx,%ebp
jl     1450 <get_nth_alternative+0x2f0>
add    $0xffffffff,%ecx
test   %dl,%dl
jne    148e <get_nth_alternative+0x32e>
test   $0x1,%sil
je     148e <get_nth_alternative+0x32e>
mov    %ecx,%eax
mov    (%rbx,%rax,8),%rdi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <xstrdup@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i8* @get_nth_alternative(i8* %0, i32 %1) {
%3 = icmp eq i8* %0, null
br i1 %3, label %170, label %4
4: ; preds = %2
%5 = tail call i64 @strlen(i8* %0)
%6 = add i64 %5, 2
%7 = tail call i64 @alloca(i64 %6)
%8 = inttoptr i64 %7 to i8*
%9 = add i64 %5, 1
%10 = tail call i32 @memcpy(i8* %8, i8* %0, i64 %9)
br label %11
11: ; preds = %14, %4
%12 = phi i64 [ %5, %4 ], [ %15, %14 ]
%13 = icmp eq i64 %12, 0
br i1 %13, label %170, label %14
14: ; preds = %11
%15 = add i64 %12, -1
%16 = getelementptr inbounds i8, i8* %8, i64 %15
%17 = load i8, i8* %16
%18 = tail call i64 @isspace(i8 zeroext %17)
%19 = icmp eq i64 %18, 0
br i1 %19, label %20, label %11
20: ; preds = %14
%21 = add i64 %12, 1
%22 = getelementptr inbounds i8, i8* %8, i64 %12
store i8 10, i8* %22
%23 = getelementptr inbounds i8, i8* %8, i64 %21
store i8 0, i8* %23
br label %24
24: ; preds = %30, %20
%25 = phi i8* [ %8, %20 ], [ %32, %30 ]
%26 = phi i32 [ 0, %20 ], [ %31, %30 ]
%27 = load i8, i8* %25
switch i8 %27, label %30 [
i8 0, label %33
i8 10, label %28
]
28: ; preds = %24
%29 = add nsw i32 %26, 1
br label %30
30: ; preds = %24, %28
%31 = phi i32 [ %29, %28 ], [ %26, %24 ]
%32 = getelementptr inbounds i8, i8* %25, i64 1
br label %24
33: ; preds = %24
%34 = add nsw i32 %26, 1
%35 = sext i32 %34 to i64
%36 = shl nsw i64 %35, 3
%37 = tail call i64 @alloca(i64 %36)
%38 = inttoptr i64 %37 to i8**
%39 = trunc i64 %36 to i32
%40 = tail call i32 @memset(i8** %38, i32 0, i32 %39)
%41 = load i8, i8* %8
%42 = icmp eq i8 %41, 0
br i1 %42, label %55, label %43
43: ; preds = %33, %147
%44 = phi i64 [ %149, %147 ], [ 0, %33 ]
%45 = phi i8 [ %151, %147 ], [ %41, %33 ]
%46 = phi i8* [ %127, %147 ], [ %8, %33 ]
br label %47
47: ; preds = %43, %120
%48 = phi i8 [ %45, %43 ], [ %123, %120 ]
%49 = phi i8* [ %46, %43 ], [ %122, %120 ]
%50 = icmp eq i8 %48, 10
br i1 %50, label %120, label %104
51: ; preds = %120
%52 = trunc i64 %44 to i32
br label %55
53: ; preds = %147
%54 = trunc i64 %149 to i32
br label %55
55: ; preds = %53, %51, %33
%56 = phi i32 [ 0, %33 ], [ %52, %51 ], [ %54, %53 ]
%57 = add i32 %1, -1
%58 = call i32 @llvm.smax.i32(i32 %56, i32 0)
%59 = icmp eq i32 %57, 0
%60 = call i32 @llvm.umin.i32(i32 %58, i32 %57)
%61 = add nuw i32 %60, 1
%62 = select i1 %59, i32 1, i32 %61
%63 = icmp ult i32 %62, 16
br i1 %63, label %102, label %64
64: ; preds = %55
%65 = and i32 %62, -16
%66 = insertelement <16 x i32> poison, i32 %56, i64 0
%67 = shufflevector <16 x i32> %66, <16 x i32> poison, <16 x i32> zeroinitializer
%68 = add i32 %65, -16
%69 = lshr exact i32 %68, 4
%70 = add nuw nsw i32 %69, 1
%71 = and i32 %70, 7
%72 = icmp ult i32 %68, 112
br i1 %72, label %83, label %73
73: ; preds = %64
%74 = and i32 %70, 536870904
br label %75
75: ; preds = %75, %73
%76 = phi <16 x i32> [ <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>, %73 ], [ %78, %75 ]
%77 = phi i32 [ 0, %73 ], [ %79, %75 ]
%78 = add <16 x i32> %76, <i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128, i32 128>
%79 = add i32 %77, 8
%80 = icmp eq i32 %79, %74
br i1 %80, label %81, label %75
81: ; preds = %75
%82 = add <16 x i32> %76, <i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112, i32 112>
br label %83
83: ; preds = %81, %64
%84 = phi <16 x i32> [ undef, %64 ], [ %82, %81 ]
%85 = phi <16 x i32> [ <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>, %64 ], [ %78, %81 ]
%86 = icmp eq i32 %71, 0
br i1 %86, label %93, label %87
87: ; preds = %83, %87
%88 = phi <16 x i32> [ %90, %87 ], [ %85, %83 ]
%89 = phi i32 [ %91, %87 ], [ 0, %83 ]
%90 = add <16 x i32> %88, <i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16>
%91 = add i32 %89, 1
%92 = icmp eq i32 %91, %71
br i1 %92, label %93, label %87
93: ; preds = %87, %83
%94 = phi <16 x i32> [ %84, %83 ], [ %88, %87 ]
%95 = icmp slt <16 x i32> %94, %67
%96 = icmp eq i32 %62, %65
%97 = add i32 %65, -1
%98 = extractelement <16 x i32> %94, i64 15
%99 = add nuw nsw i32 %98, 1
%100 = icmp ne i32 %99, %1
%101 = extractelement <16 x i1> %95, i64 15
br i1 %96, label %159, label %102
102: ; preds = %55, %93
%103 = phi i32 [ 0, %55 ], [ %65, %93 ]
br label %153
104: ; preds = %47, %109
%105 = phi i8* [ %110, %109 ], [ %49, %47 ]
%106 = phi i8 [ %111, %109 ], [ %48, %47 ]
%107 = tail call i64 @isspace(i8 zeroext %106)
%108 = icmp eq i64 %107, 0
br i1 %108, label %113, label %109
109: ; preds = %104
%110 = getelementptr inbounds i8, i8* %105, i64 1
%111 = load i8, i8* %110
%112 = icmp eq i8 %111, 10
br i1 %112, label %120, label %104
113: ; preds = %104
%114 = load i8, i8* %105
switch i8 %114, label %125 [
i8 35, label %115
i8 10, label %120
]
115: ; preds = %113, %115
%116 = phi i8* [ %117, %115 ], [ %105, %113 ]
%117 = getelementptr inbounds i8, i8* %116, i64 1
%118 = load i8, i8* %117
%119 = icmp eq i8 %118, 10
br i1 %119, label %120, label %115
120: ; preds = %109, %115, %113, %47
%121 = phi i8* [ %49, %47 ], [ %105, %113 ], [ %117, %115 ], [ %110, %109 ]
%122 = getelementptr inbounds i8, i8* %121, i64 1
%123 = load i8, i8* %122
%124 = icmp eq i8 %123, 0
br i1 %124, label %51, label %47
125: ; preds = %113, %125
%126 = phi i8* [ %127, %125 ], [ %105, %113 ]
%127 = getelementptr inbounds i8, i8* %126, i64 1
%128 = load i8, i8* %127
%129 = icmp eq i8 %128, 10
br i1 %129, label %130, label %125
130: ; preds = %125
%131 = ptrtoint i8* %127 to i64
%132 = ptrtoint i8* %105 to i64
%133 = sub i64 %131, %132
%134 = add i64 %133, 1
%135 = tail call i64 @alloca(i64 %134)
%136 = inttoptr i64 %135 to i8*
%137 = tail call i32 @memcpy(i8* %136, i8* %105, i64 %133)
br label %138
138: ; preds = %141, %130
%139 = phi i64 [ %133, %130 ], [ %142, %141 ]
%140 = icmp eq i64 %139, 0
br i1 %140, label %147, label %141
141: ; preds = %138
%142 = add i64 %139, -1
%143 = getelementptr inbounds i8, i8* %136, i64 %142
%144 = load i8, i8* %143
%145 = tail call i64 @isspace(i8 zeroext %144)
%146 = icmp eq i64 %145, 0
br i1 %146, label %147, label %138
147: ; preds = %138, %141
%148 = getelementptr inbounds i8, i8* %136, i64 %139
store i8 0, i8* %148
%149 = add nuw i64 %44, 1
%150 = getelementptr inbounds i8*, i8** %38, i64 %44
store i8* %136, i8** %150
%151 = load i8, i8* %127
%152 = icmp eq i8 %151, 0
br i1 %152, label %53, label %43
153: ; preds = %102, %153
%154 = phi i32 [ %155, %153 ], [ %103, %102 ]
%155 = add nuw nsw i32 %154, 1
%156 = icmp ne i32 %155, %1
%157 = icmp slt i32 %154, %56
%158 = select i1 %156, i1 %157, i1 false
br i1 %158, label %153, label %159
159: ; preds = %153, %93
%160 = phi i32 [ %97, %93 ], [ %154, %153 ]
%161 = phi i1 [ %100, %93 ], [ %156, %153 ]
%162 = phi i1 [ %101, %93 ], [ %157, %153 ]
%163 = xor i1 %162, true
%164 = select i1 %161, i1 true, i1 %163
br i1 %164, label %170, label %165
165: ; preds = %159
%166 = zext i32 %160 to i64
%167 = getelementptr inbounds i8*, i8** %38, i64 %166
%168 = load i8*, i8** %167
%169 = tail call i8* @xstrdup(i8* %168)
br label %170
170: ; preds = %11, %159, %2, %165
%171 = phi i8* [ %169, %165 ], [ null, %2 ], [ null, %159 ], [ null, %11 ]
ret i8* %171
}