#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*/ bug(char *);
int /*<<< orphan*/ isdelim(char);
scalar_t__ malloc(scalar_t__);
scalar_t__ strlen(char *);
char *strnl(char *s) {
  char *t, *u;
  int neg;
  t = (char *)malloc(strlen(s) + 1);
  u = t;
  if (!isdelim(*s))
    bug("character not allowed to start a syntax specifier");
  while (*s != 0) {
    if (((*s & 0x60) == 0) && (*s != '\n') && (*s != '\t'))
      bug("character not allowed in syntax specifier");
    if (*s == '\\') {
      neg = (s[1] == '!');
      switch (s[neg + 1]) {
      case 'n':
      case 'r':
        *u = '\n';
        break;
      case 't':
        *u = '\t';
        break;
      case 'b':
        *u = '\001';
        break;
      case 'w':
        if (neg)
          bug("\\w and \\W cannot be negated");
        *u = '\002';
        break;
      case 'B':
        *u = '\003';
        break;
      case 'W':
        if (neg)
          bug("\\w and \\W cannot be negated");
        *u = '\004';
        break;
      case 'a':
        *u = '\005';
        break;
      case 'A':
        *u = '\006';
        break;
      case '#':
        *u = '\007';
        break;
      case 'i':
        *u = '\010';
        break;
      case 'o':
        *u = '\013';
        break;
      case 'O':
        *u = '\014';
        break;
      default:
        *u = '\\';
        neg = -1;
      }
      if (neg > 0)
        *u += (char)128;
      s += neg + 1;
    } else if (*s == ' ')
      *u = '\001';
    else
      *u = *s;
    s++;
    u++;
  }
  *u = 0;
  return t;
}


x86 assembly (clang, -O0):
<strnl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,%rdi
add    $0x1,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%edi
call   1060 <isdelim@plt>
cmp    $0x0,%eax
jne    118e <strnl+0x4e>
lea    0xfcb(%rip),%rdi
call   1030 <bug@plt>
jmp    1193 <strnl+0x53>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     137a <strnl+0x23a>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
and    $0x60,%eax
cmp    $0x0,%eax
jne    11e2 <strnl+0xa2>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
je     11e2 <strnl+0xa2>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x9,%eax
je     11e2 <strnl+0xa2>
lea    0xfa9(%rip),%rdi
call   1030 <bug@plt>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    1330 <strnl+0x1f0>
mov    -0x8(%rbp),%rax
mov    0x1(%rax),%al
sub    $0x21,%al
sete   %al
movzbl %al,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rax
movsbl 0x1(%rax,%rcx,1),%eax
add    $0xffffffdd,%eax
mov    %eax,%ecx
mov    %rcx,-0x28(%rbp)
sub    $0x54,%eax
ja     12f3 <strnl+0x1b3>
mov    -0x28(%rbp),%rax
lea    0xdd2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
movb   $0xa,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x9,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x1,(%rax)
jmp    1301 <strnl+0x1c1>
cmpl   $0x0,-0x1c(%rbp)
je     1271 <strnl+0x131>
lea    0xf44(%rip),%rdi
call   1030 <bug@plt>
mov    -0x18(%rbp),%rax
movb   $0x2,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x3,(%rax)
jmp    1301 <strnl+0x1c1>
cmpl   $0x0,-0x1c(%rbp)
je     129f <strnl+0x15f>
lea    0xf16(%rip),%rdi
call   1030 <bug@plt>
mov    -0x18(%rbp),%rax
movb   $0x4,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x5,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x6,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x7,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x8,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0xb,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0xc,(%rax)
jmp    1301 <strnl+0x1c1>
mov    -0x18(%rbp),%rax
movb   $0x5c,(%rax)
movl   $0xffffffff,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1317 <strnl+0x1d7>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
add    $0xffffff80,%ecx
mov    %cl,(%rax)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    135d <strnl+0x21d>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    134c <strnl+0x20c>
mov    -0x18(%rbp),%rax
movb   $0x1,(%rax)
jmp    1358 <strnl+0x218>
mov    -0x8(%rbp),%rax
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
jmp    135d <strnl+0x21d>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1193 <strnl+0x53>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strnl>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%rbx
call   1040 <strlen@plt>
lea    0x1(%rax),%rdi
call   1050 <malloc@plt>
mov    %rax,%rbp
movsbl (%rbx),%edi
call   1060 <isdelim@plt>
test   %eax,%eax
jne    1177 <strnl+0x37>
lea    0xfe2(%rip),%rdi
call   1030 <bug@plt>
mov    (%rbx),%al
test   %al,%al
mov    %rbp,(%rsp)
je     12a5 <strnl+0x165>
lea    0xe74(%rip),%r13
jmp    11a7 <strnl+0x67>
xchg   %ax,%ax
mov    %al,0x0(%rbp)
add    $0x1,%rbp
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
je     12a5 <strnl+0x165>
test   $0x60,%al
jne    11c4 <strnl+0x84>
mov    %eax,%ecx
add    $0xf7,%cl
cmp    $0x2,%cl
jb     11c4 <strnl+0x84>
lea    0xfca(%rip),%rdi
call   1030 <bug@plt>
movzbl (%rbx),%eax
cmp    $0x20,%al
je     1210 <strnl+0xd0>
cmp    $0x5c,%al
jne    1190 <strnl+0x50>
movzbl 0x1(%rbx),%r15d
xor    %eax,%eax
cmp    $0x21,%r15b
sete   %al
movsbl 0x1(%rax,%rbx,1),%edx
mov    $0x5c,%cl
xor    %eax,%eax
add    $0xffffffdd,%edx
cmp    $0x54,%edx
ja     1293 <strnl+0x153>
mov    $0x8a,%r14b
mov    $0xa,%r12b
movslq 0x0(%r13,%rdx,4),%rdx
add    %r13,%rdx
jmp    *%rdx
mov    $0x87,%r14b
mov    $0x7,%r12b
jmp    1280 <strnl+0x140>
nopw   0x0(%rax,%rax,1)
movb   $0x1,0x0(%rbp)
jmp    1193 <strnl+0x53>
mov    $0x86,%r14b
mov    $0x6,%r12b
jmp    1280 <strnl+0x140>
mov    $0x83,%r14b
mov    $0x3,%r12b
jmp    1280 <strnl+0x140>
mov    $0x8c,%r14b
mov    $0xc,%r12b
jmp    1280 <strnl+0x140>
mov    $0x84,%r14b
mov    $0x4,%r12b
cmp    $0x21,%r15b
je     1273 <strnl+0x133>
jmp    1280 <strnl+0x140>
mov    $0x85,%r14b
mov    $0x5,%r12b
jmp    1280 <strnl+0x140>
mov    $0x81,%r14b
mov    $0x1,%r12b
jmp    1280 <strnl+0x140>
mov    $0x88,%r14b
mov    $0x8,%r12b
jmp    1280 <strnl+0x140>
mov    $0x8b,%r14b
mov    $0xb,%r12b
jmp    1280 <strnl+0x140>
mov    $0x89,%r14b
mov    $0x9,%r12b
jmp    1280 <strnl+0x140>
mov    $0x82,%r14b
mov    $0x2,%r12b
cmp    $0x21,%r15b
jne    1280 <strnl+0x140>
lea    0xf36(%rip),%rdi
call   1030 <bug@plt>
nop
mov    $0x1,%edx
mov    $0x2,%eax
mov    %r14d,%ecx
cmp    $0x21,%r15b
jne    1299 <strnl+0x159>
mov    %ecx,%r12d
mov    %rax,%rdx
mov    %r12b,0x0(%rbp)
add    %rdx,%rbx
jmp    1193 <strnl+0x53>
movb   $0x0,0x0(%rbp)
mov    (%rsp),%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [50 x i8] c"character not allowed to start a syntax specifier\00"
@.str.1 = [42 x i8] c"character not allowed in syntax specifier\00"
@.str.2 = [28 x i8] c"\\w and \\W cannot be negated\00"
define i8* @strnl(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
store i8* %0, i8** %2
%6 = load i8*, i8** %2
%7 = call i64 @strlen(i8* %6)
%8 = add nsw i64 %7, 1
%9 = call i64 @malloc(i64 %8)
%10 = inttoptr i64 %9 to i8*
store i8* %10, i8** %3
%11 = load i8*, i8** %3
store i8* %11, i8** %4
%12 = load i8*, i8** %2
%13 = load i8, i8* %12
%14 = call i32 @isdelim(i8 signext %13)
%15 = icmp ne i32 %14, 0
br i1 %15, label %18, label %16
16: ; preds = %1
%17 = call i32 @bug(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0))
br label %18
18: ; preds = %16, %1
br label %19
19: ; preds = %124, %18
%20 = load i8*, i8** %2
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = icmp ne i32 %22, 0
br i1 %23, label %24, label %129
24: ; preds = %19
%25 = load i8*, i8** %2
%26 = load i8, i8* %25
%27 = sext i8 %26 to i32
%28 = and i32 %27, 96
%29 = icmp eq i32 %28, 0
br i1 %29, label %30, label %42
30: ; preds = %24
%31 = load i8*, i8** %2
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
%34 = icmp ne i32 %33, 10
br i1 %34, label %35, label %42
35: ; preds = %30
%36 = load i8*, i8** %2
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp ne i32 %38, 9
br i1 %39, label %40, label %42
40: ; preds = %35
%41 = call i32 @bug(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0))
br label %42
42: ; preds = %40, %35, %30, %24
%43 = load i8*, i8** %2
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 92
br i1 %46, label %47, label %112
47: ; preds = %42
%48 = load i8*, i8** %2
%49 = getelementptr inbounds i8, i8* %48, i64 1
%50 = load i8, i8* %49
%51 = sext i8 %50 to i32
%52 = icmp eq i32 %51, 33
%53 = zext i1 %52 to i32
store i32 %53, i32* %5
%54 = load i8*, i8** %2
%55 = load i32, i32* %5
%56 = add nsw i32 %55, 1
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %54, i64 %57
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
switch i32 %60, label %95 [
i32 110, label %61
i32 114, label %61
i32 116, label %63
i32 98, label %65
i32 119, label %67
i32 66, label %74
i32 87, label %76
i32 97, label %83
i32 65, label %85
i32 35, label %87
i32 105, label %89
i32 111, label %91
i32 79, label %93
]
61: ; preds = %47, %47
%62 = load i8*, i8** %4
store i8 10, i8* %62
br label %97
63: ; preds = %47
%64 = load i8*, i8** %4
store i8 9, i8* %64
br label %97
65: ; preds = %47
%66 = load i8*, i8** %4
store i8 1, i8* %66
br label %97
67: ; preds = %47
%68 = load i32, i32* %5
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %72
70: ; preds = %67
%71 = call i32 @bug(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0))
br label %72
72: ; preds = %70, %67
%73 = load i8*, i8** %4
store i8 2, i8* %73
br label %97
74: ; preds = %47
%75 = load i8*, i8** %4
store i8 3, i8* %75
br label %97
76: ; preds = %47
%77 = load i32, i32* %5
%78 = icmp ne i32 %77, 0
br i1 %78, label %79, label %81
79: ; preds = %76
%80 = call i32 @bug(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0))
br label %81
81: ; preds = %79, %76
%82 = load i8*, i8** %4
store i8 4, i8* %82
br label %97
83: ; preds = %47
%84 = load i8*, i8** %4
store i8 5, i8* %84
br label %97
85: ; preds = %47
%86 = load i8*, i8** %4
store i8 6, i8* %86
br label %97
87: ; preds = %47
%88 = load i8*, i8** %4
store i8 7, i8* %88
br label %97
89: ; preds = %47
%90 = load i8*, i8** %4
store i8 8, i8* %90
br label %97
91: ; preds = %47
%92 = load i8*, i8** %4
store i8 11, i8* %92
br label %97
93: ; preds = %47
%94 = load i8*, i8** %4
store i8 12, i8* %94
br label %97
95: ; preds = %47
%96 = load i8*, i8** %4
store i8 92, i8* %96
store i32 -1, i32* %5
br label %97
97: ; preds = %95, %93, %91, %89, %87, %85, %83, %81, %74, %72, %65, %63, %61
%98 = load i32, i32* %5
%99 = icmp sgt i32 %98, 0
br i1 %99, label %100, label %106
100: ; preds = %97
%101 = load i8*, i8** %4
%102 = load i8, i8* %101
%103 = sext i8 %102 to i32
%104 = add nsw i32 %103, -128
%105 = trunc i32 %104 to i8
store i8 %105, i8* %101
br label %106
106: ; preds = %100, %97
%107 = load i32, i32* %5
%108 = add nsw i32 %107, 1
%109 = load i8*, i8** %2
%110 = sext i32 %108 to i64
%111 = getelementptr inbounds i8, i8* %109, i64 %110
store i8* %111, i8** %2
br label %124
112: ; preds = %42
%113 = load i8*, i8** %2
%114 = load i8, i8* %113
%115 = sext i8 %114 to i32
%116 = icmp eq i32 %115, 32
br i1 %116, label %117, label %119
117: ; preds = %112
%118 = load i8*, i8** %4
store i8 1, i8* %118
br label %123
119: ; preds = %112
%120 = load i8*, i8** %2
%121 = load i8, i8* %120
%122 = load i8*, i8** %4
store i8 %121, i8* %122
br label %123
123: ; preds = %119, %117
br label %124
124: ; preds = %123, %106
%125 = load i8*, i8** %2
%126 = getelementptr inbounds i8, i8* %125, i32 1
store i8* %126, i8** %2
%127 = load i8*, i8** %4
%128 = getelementptr inbounds i8, i8* %127, i32 1
store i8* %128, i8** %4
br label %19
129: ; preds = %19
%130 = load i8*, i8** %4
store i8 0, i8* %130
%131 = load i8*, i8** %3
ret i8* %131
}

LLVM IR (-O2):
@.str = [50 x i8] c"character not allowed to start a syntax specifier\00"
@.str.1 = [42 x i8] c"character not allowed in syntax specifier\00"
@.str.2 = [28 x i8] c"\\w and \\W cannot be negated\00"
define i8* @strnl(i8* nocapture %0) {
%2 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%3 = add nsw i64 %2, 1
%4 = tail call i64 @malloc(i64 %3)
%5 = inttoptr i64 %4 to i8*
%6 = load i8, i8* %0
%7 = tail call i32 @isdelim(i8 signext %6)
%8 = icmp eq i32 %7, 0
br i1 %8, label %9, label %11
9: ; preds = %1
%10 = tail call i32 @bug(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0))
br label %11
11: ; preds = %9, %1
%12 = load i8, i8* %0
%13 = icmp eq i8 %12, 0
br i1 %13, label %70, label %14
14: ; preds = %11, %64
%15 = phi i8 [ %68, %64 ], [ %12, %11 ]
%16 = phi i8* [ %67, %64 ], [ %5, %11 ]
%17 = phi i8* [ %66, %64 ], [ %0, %11 ]
%18 = freeze i8 %15
%19 = and i8 %18, 96
%20 = icmp ne i8 %19, 0
%21 = add i8 %18, -9
%22 = icmp ult i8 %21, 2
%23 = or i1 %20, %22
br i1 %23, label %27, label %24
24: ; preds = %14
%25 = tail call i32 @bug(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0))
%26 = load i8, i8* %17
br label %27
27: ; preds = %14, %24
%28 = phi i8 [ %18, %14 ], [ %26, %24 ]
switch i8 %28, label %63 [
i8 92, label %29
i8 32, label %62
]
29: ; preds = %27
%30 = getelementptr inbounds i8, i8* %17, i64 1
%31 = load i8, i8* %30
%32 = icmp eq i8 %31, 33
%33 = select i1 %32, i64 2, i64 1
%34 = getelementptr inbounds i8, i8* %17, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
switch i32 %36, label %55 [
i32 110, label %52
i32 114, label %52
i32 116, label %37
i32 98, label %38
i32 119, label %39
i32 66, label %42
i32 87, label %43
i32 97, label %46
i32 65, label %47
i32 35, label %48
i32 105, label %49
i32 111, label %50
i32 79, label %51
]
37: ; preds = %29
br label %52
38: ; preds = %29
br label %52
39: ; preds = %29
br i1 %32, label %40, label %52
40: ; preds = %39
%41 = tail call i32 @bug(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0))
br label %52
42: ; preds = %29
br label %52
43: ; preds = %29
br i1 %32, label %44, label %52
44: ; preds = %43
%45 = tail call i32 @bug(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0))
br label %52
46: ; preds = %29
br label %52
47: ; preds = %29
br label %52
48: ; preds = %29
br label %52
49: ; preds = %29
br label %52
50: ; preds = %29
br label %52
51: ; preds = %29
br label %52
52: ; preds = %43, %44, %39, %40, %29, %29, %51, %50, %49, %48, %47, %46, %42, %38, %37
%53 = phi i8 [ 12, %51 ], [ 11, %50 ], [ 8, %49 ], [ 7, %48 ], [ 6, %47 ], [ 5, %46 ], [ 3, %42 ], [ 1, %38 ], [ 9, %37 ], [ 10, %29 ], [ 10, %29 ], [ 2, %40 ], [ 2, %39 ], [ 4, %44 ], [ 4, %43 ]
%54 = phi i8 [ -116, %51 ], [ -117, %50 ], [ -120, %49 ], [ -121, %48 ], [ -122, %47 ], [ -123, %46 ], [ -125, %42 ], [ -127, %38 ], [ -119, %37 ], [ -118, %29 ], [ -118, %29 ], [ -126, %40 ], [ -126, %39 ], [ -124, %44 ], [ -124, %43 ]
br i1 %32, label %55, label %58
55: ; preds = %52, %29
%56 = phi i8 [ 92, %29 ], [ %54, %52 ]
%57 = phi i64 [ 0, %29 ], [ 2, %52 ]
br label %58
58: ; preds = %55, %52
%59 = phi i8 [ %56, %55 ], [ %53, %52 ]
%60 = phi i64 [ %57, %55 ], [ 1, %52 ]
store i8 %59, i8* %16
%61 = getelementptr inbounds i8, i8* %17, i64 %60
br label %64
62: ; preds = %27
store i8 1, i8* %16
br label %64
63: ; preds = %27
store i8 %28, i8* %16
br label %64
64: ; preds = %62, %63, %58
%65 = phi i8* [ %61, %58 ], [ %17, %62 ], [ %17, %63 ]
%66 = getelementptr inbounds i8, i8* %65, i64 1
%67 = getelementptr inbounds i8, i8* %16, i64 1
%68 = load i8, i8* %66
%69 = icmp eq i8 %68, 0
br i1 %69, label %70, label %14
70: ; preds = %64, %11
%71 = phi i8* [ %5, %11 ], [ %67, %64 ]
store i8 0, i8* %71
ret i8* %5
}