#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 */
scalar_t__ isspace(unsigned char);
void *x2c(unsigned char *);
int /*<<< orphan*/ xsingle2c(unsigned char *);
int css_decode(unsigned char *input, long int input_len) {
  unsigned char *d = (unsigned char *)input;
  long int i, j, count;
  if (input == NULL)
    return -1;
  i = count = 0;
  while (i < input_len) {
    if (input[i] == '\\') {
      if (i + 1 < input_len) {
        i++;
        j = 0;
        while ((j < 6) && (i + j < input_len) &&
               ((((input[i + j] >= '0') && (input[i + j] <= '9')) ||
                 ((input[i + j] >= 'a') && (input[i + j] <= 'f')) ||
                 ((input[i + j] >= 'A') && (input[i + j] <= 'F'))))) {
          j++;
        }
        if (j > 0) {
          int fullcheck = 0;
          switch (j) {
          case 1:
            *d++ = xsingle2c(&input[i]);
            break;
          case 2:
          case 3:
            *d++ = x2c(&input[i + j - 2]);
            break;
          case 4:
            *d = x2c(&input[i + j - 2]);
            fullcheck = 1;
            break;
          case 5:
            *d = x2c(&input[i + j - 2]);
            if (input[i] == '0') {
              fullcheck = 1;
            } else {
              d++;
            }
            break;
          case 6:
            *d = x2c(&input[i + j - 2]);
            if ((input[i] == '0') && (input[i + 1] == '0')) {
              fullcheck = 1;
            } else {
              d++;
            }
            break;
          }
          if (fullcheck) {
            if ((*d > 0x00) && (*d < 0x5f) &&
                ((input[i + j - 3] == 'f') || (input[i + j - 3] == 'F')) &&
                ((input[i + j - 4] == 'f') || (input[i + j - 4] == 'F'))) {
              (*d) += 0x20;
            }
            d++;
          }
          if ((i + j < input_len) && isspace(input[i + j])) {
            j++;
          }
          count++;
          i += j;
        } else if (input[i] == '\n') {
          i++;
        } else {
          *d++ = input[i++];
          count++;
        }
      } else {
        i++;
      }
    } else {
      *d++ = input[i++];
      count++;
    }
  }
  *d = '\0';
  return d - input;
}


x86 assembly (clang, -O0):
<css_decode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    115f <css_decode+0x2f>
movl   $0xffffffff,-0x4(%rbp)
jmp    15f9 <css_decode+0x4c9>
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    15e4 <css_decode+0x4b4>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    15ac <css_decode+0x47c>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
cmp    -0x18(%rbp),%rax
jge    159b <css_decode+0x46b>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
xor    %eax,%eax
cmpq   $0x6,-0x30(%rbp)
mov    %al,-0x3d(%rbp)
jge    1290 <css_decode+0x160>
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x18(%rbp),%rcx
mov    %al,-0x3d(%rbp)
jge    1290 <css_decode+0x160>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     1216 <css_decode+0xe6>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x39,%ecx
mov    %al,-0x3e(%rbp)
jle    128a <css_decode+0x15a>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     124d <css_decode+0x11d>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x66,%ecx
mov    %al,-0x3e(%rbp)
jle    128a <css_decode+0x15a>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x41,%ecx
mov    %al,-0x3f(%rbp)
jl     1284 <css_decode+0x154>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
setle  %al
mov    %al,-0x3f(%rbp)
mov    -0x3f(%rbp),%al
mov    %al,-0x3e(%rbp)
mov    -0x3e(%rbp),%al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    12a0 <css_decode+0x170>
jmp    12b1 <css_decode+0x181>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11b8 <css_decode+0x88>
cmpq   $0x0,-0x30(%rbp)
jle    1538 <css_decode+0x408>
movl   $0x0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
sub    $0x5,%rax
ja     1428 <css_decode+0x2f8>
mov    -0x48(%rbp),%rax
lea    0xd1c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rdi
add    -0x28(%rbp),%rdi
call   1040 <xsingle2c@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    1428 <css_decode+0x2f8>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
sub    $0x2,%rax
add    %rax,%rdi
call   1050 <x2c@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    1428 <css_decode+0x2f8>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
sub    $0x2,%rax
add    %rax,%rdi
call   1050 <x2c@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
movl   $0x1,-0x3c(%rbp)
jmp    1428 <css_decode+0x2f8>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
sub    $0x2,%rax
add    %rax,%rdi
call   1050 <x2c@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    13af <css_decode+0x27f>
movl   $0x1,-0x3c(%rbp)
jmp    13bb <css_decode+0x28b>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1428 <css_decode+0x2f8>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
sub    $0x2,%rax
add    %rax,%rdi
call   1050 <x2c@plt>
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    1417 <css_decode+0x2e7>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
cmp    $0x30,%eax
jne    1417 <css_decode+0x2e7>
movl   $0x1,-0x3c(%rbp)
jmp    1423 <css_decode+0x2f3>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1428 <css_decode+0x2f8>
cmpl   $0x0,-0x3c(%rbp)
je     14de <css_decode+0x3ae>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x0,%eax
jle    14d2 <css_decode+0x3a2>
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x5f,%eax
jge    14d2 <css_decode+0x3a2>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
sub    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x66,%eax
je     148c <css_decode+0x35c>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
sub    $0x3,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jne    14d2 <css_decode+0x3a2>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
sub    $0x4,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x66,%eax
je     14c6 <css_decode+0x396>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
sub    $0x4,%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jne    14d2 <css_decode+0x3a2>
mov    -0x20(%rbp),%rax
movzbl (%rax),%ecx
add    $0x20,%ecx
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    151b <css_decode+0x3eb>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1030 <isspace@plt>
cmp    $0x0,%rax
je     151b <css_decode+0x3eb>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    1596 <css_decode+0x466>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    155e <css_decode+0x42e>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1591 <css_decode+0x461>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1596 <css_decode+0x466>
jmp    15a7 <css_decode+0x477>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    15df <css_decode+0x4af>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,1),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    116f <css_decode+0x3f>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<css_decode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %rdi,%rdi
je     1421 <css_decode+0x2f1>
mov    %rsi,%r15
mov    %rdi,%r14
mov    %rdi,%r13
test   %rsi,%rsi
jle    1417 <css_decode+0x2e7>
xor    %ebp,%ebp
mov    %r14,%r13
jmp    1174 <css_decode+0x44>
nopl   (%rax)
mov    %al,0x0(%r13)
add    $0x1,%r13
mov    %rbx,%rbp
cmp    %r15,%rbp
jge    1417 <css_decode+0x2e7>
movzbl (%r14,%rbp,1),%eax
lea    0x1(%rbp),%rbx
cmp    $0x5c,%al
jne    1160 <css_decode+0x30>
cmp    %r15,%rbx
jge    1168 <css_decode+0x38>
movzbl (%r14,%rbx,1),%eax
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     11b4 <css_decode+0x84>
add    $0xbf,%al
cmp    $0x25,%al
ja     13b9 <css_decode+0x289>
movzbl %al,%eax
movabs $0x3f0000003f,%rcx
bt     %rax,%rcx
jae    13b9 <css_decode+0x289>
lea    0x2(%rbp),%rax
cmp    %r15,%rax
jge    131a <css_decode+0x1ea>
movzbl (%r14,%rax,1),%eax
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     11ef <css_decode+0xbf>
add    $0xbf,%al
cmp    $0x25,%al
ja     131a <css_decode+0x1ea>
movzbl %al,%eax
movabs $0x3f0000003f,%rcx
bt     %rax,%rcx
jae    131a <css_decode+0x1ea>
lea    0x3(%rbp),%rax
mov    $0x2,%r12d
cmp    %r15,%rax
jge    1333 <css_decode+0x203>
movzbl (%r14,%rax,1),%eax
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     1230 <css_decode+0x100>
add    $0xbf,%al
cmp    $0x25,%al
ja     1333 <css_decode+0x203>
movzbl %al,%eax
movabs $0x3f0000003f,%rcx
bt     %rax,%rcx
jae    1333 <css_decode+0x203>
lea    0x4(%rbp),%rax
mov    $0x3,%r12d
cmp    %r15,%rax
jge    1333 <css_decode+0x203>
movzbl (%r14,%rax,1),%eax
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     1271 <css_decode+0x141>
add    $0xbf,%al
cmp    $0x25,%al
ja     1333 <css_decode+0x203>
movzbl %al,%eax
movabs $0x3f0000003f,%rcx
bt     %rax,%rcx
jae    1333 <css_decode+0x203>
lea    0x5(%rbp),%rax
cmp    %r15,%rax
jge    1376 <css_decode+0x246>
movzbl (%r14,%rax,1),%eax
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     12ac <css_decode+0x17c>
add    $0xbf,%al
cmp    $0x25,%al
ja     1376 <css_decode+0x246>
movzbl %al,%eax
movabs $0x3f0000003f,%rcx
bt     %rax,%rcx
jae    1376 <css_decode+0x246>
lea    0x6(%rbp),%rax
cmp    %r15,%rax
jge    13d8 <css_decode+0x2a8>
movzbl (%r14,%rax,1),%eax
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jb     12e7 <css_decode+0x1b7>
add    $0xbf,%al
cmp    $0x25,%al
ja     13d8 <css_decode+0x2a8>
movzbl %al,%eax
movabs $0x3f0000003f,%rcx
bt     %rax,%rcx
jae    13d8 <css_decode+0x2a8>
lea    (%r14,%rbp,1),%rdi
add    $0x5,%rdi
call   1050 <x2c@plt>
mov    %al,0x0(%r13)
cmpb   $0x30,0x1(%r14,%rbp,1)
jne    130e <css_decode+0x1de>
mov    $0x6,%r12d
cmpb   $0x30,0x2(%rbp,%r14,1)
je     138d <css_decode+0x25d>
add    $0x1,%r13
mov    $0x6,%r12d
jmp    134c <css_decode+0x21c>
lea    (%r14,%rbx,1),%rdi
call   1040 <xsingle2c@plt>
mov    %al,0x0(%r13)
add    $0x1,%r13
mov    $0x1,%r12d
jmp    134c <css_decode+0x21c>
lea    (%r12,%rbx,1),%rax
lea    (%r14,%rax,1),%rdi
add    $0xfffffffffffffffe,%rdi
call   1050 <x2c@plt>
mov    %al,0x0(%r13)
add    $0x1,%r13
lea    (%r12,%rbx,1),%rbp
cmp    %r15,%rbp
jge    116b <css_decode+0x3b>
movzbl (%r14,%rbp,1),%edi
call   1030 <isspace@plt>
cmp    $0x1,%rax
sbb    $0xffffffffffffffff,%r12
add    %rbx,%r12
mov    %r12,%rbp
jmp    116b <css_decode+0x3b>
lea    (%r14,%rbp,1),%rdi
add    $0x3,%rdi
call   1050 <x2c@plt>
mov    %al,0x0(%r13)
mov    $0x4,%r12d
lea    -0x1(%rax),%ecx
cmp    $0x5d,%cl
ja     1348 <css_decode+0x218>
lea    (%r12,%rbx,1),%rcx
movzbl -0x3(%r14,%rcx,1),%edx
or     $0x20,%dl
cmp    $0x66,%dl
jne    1348 <css_decode+0x218>
movzbl -0x4(%rcx,%r14,1),%ecx
or     $0x20,%cl
cmp    $0x66,%cl
jne    1348 <css_decode+0x218>
add    $0x20,%al
jmp    1344 <css_decode+0x214>
movzbl 0x1(%r14,%rbp,1),%eax
add    $0x2,%rbp
cmp    $0xa,%al
je     116b <css_decode+0x3b>
mov    %al,0x0(%r13)
add    $0x1,%r13
jmp    116b <css_decode+0x3b>
lea    (%r14,%rbp,1),%rdi
add    $0x4,%rdi
call   1050 <x2c@plt>
mov    %al,0x0(%r13)
movzbl 0x1(%r14,%rbp,1),%eax
xor    %ecx,%ecx
cmp    $0x30,%al
setne  %cl
add    %rcx,%r13
mov    $0x5,%r12d
cmp    $0x30,%al
jne    134c <css_decode+0x21c>
movzbl 0x0(%r13),%eax
mov    $0x5,%r12d
jmp    138d <css_decode+0x25d>
movb   $0x0,0x0(%r13)
sub    %r14d,%r13d
jmp    1427 <css_decode+0x2f7>
mov    $0xffffffff,%r13d
mov    %r13d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @css_decode(i8* %0, i64 %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32
store i8* %0, i8** %4
store i64 %1, i64* %5
%11 = load i8*, i8** %4
store i8* %11, i8** %6
%12 = load i8*, i8** %4
%13 = icmp eq i8* %12, null
br i1 %13, label %14, label %15
14: ; preds = %2
store i32 -1, i32* %3
br label %322
15: ; preds = %2
store i64 0, i64* %9
store i64 0, i64* %7
br label %16
16: ; preds = %313, %15
%17 = load i64, i64* %7
%18 = load i64, i64* %5
%19 = icmp slt i64 %17, %18
br i1 %19, label %20, label %314
20: ; preds = %16
%21 = load i8*, i8** %4
%22 = load i64, i64* %7
%23 = getelementptr inbounds i8, i8* %21, i64 %22
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = icmp eq i32 %25, 92
br i1 %26, label %27, label %303
27: ; preds = %20
%28 = load i64, i64* %7
%29 = add nsw i64 %28, 1
%30 = load i64, i64* %5
%31 = icmp slt i64 %29, %30
br i1 %31, label %32, label %299
32: ; preds = %27
%33 = load i64, i64* %7
%34 = add nsw i64 %33, 1
store i64 %34, i64* %7
store i64 0, i64* %8
br label %35
35: ; preds = %104, %32
%36 = load i64, i64* %8
%37 = icmp slt i64 %36, 6
br i1 %37, label %38, label %102
38: ; preds = %35
%39 = load i64, i64* %7
%40 = load i64, i64* %8
%41 = add nsw i64 %39, %40
%42 = load i64, i64* %5
%43 = icmp slt i64 %41, %42
br i1 %43, label %44, label %102
44: ; preds = %38
%45 = load i8*, i8** %4
%46 = load i64, i64* %7
%47 = load i64, i64* %8
%48 = add nsw i64 %46, %47
%49 = getelementptr inbounds i8, i8* %45, i64 %48
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = icmp sge i32 %51, 48
br i1 %52, label %53, label %62
53: ; preds = %44
%54 = load i8*, i8** %4
%55 = load i64, i64* %7
%56 = load i64, i64* %8
%57 = add nsw i64 %55, %56
%58 = getelementptr inbounds i8, i8* %54, i64 %57
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = icmp sle i32 %60, 57
br i1 %61, label %100, label %62
62: ; preds = %53, %44
%63 = load i8*, i8** %4
%64 = load i64, i64* %7
%65 = load i64, i64* %8
%66 = add nsw i64 %64, %65
%67 = getelementptr inbounds i8, i8* %63, i64 %66
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = icmp sge i32 %69, 97
br i1 %70, label %71, label %80
71: ; preds = %62
%72 = load i8*, i8** %4
%73 = load i64, i64* %7
%74 = load i64, i64* %8
%75 = add nsw i64 %73, %74
%76 = getelementptr inbounds i8, i8* %72, i64 %75
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = icmp sle i32 %78, 102
br i1 %79, label %100, label %80
80: ; preds = %71, %62
%81 = load i8*, i8** %4
%82 = load i64, i64* %7
%83 = load i64, i64* %8
%84 = add nsw i64 %82, %83
%85 = getelementptr inbounds i8, i8* %81, i64 %84
%86 = load i8, i8* %85
%87 = zext i8 %86 to i32
%88 = icmp sge i32 %87, 65
br i1 %88, label %89, label %98
89: ; preds = %80
%90 = load i8*, i8** %4
%91 = load i64, i64* %7
%92 = load i64, i64* %8
%93 = add nsw i64 %91, %92
%94 = getelementptr inbounds i8, i8* %90, i64 %93
%95 = load i8, i8* %94
%96 = zext i8 %95 to i32
%97 = icmp sle i32 %96, 70
br label %98
98: ; preds = %89, %80
%99 = phi i1 [ false, %80 ], [ %97, %89 ]
br label %100
100: ; preds = %98, %71, %53
%101 = phi i1 [ true, %71 ], [ true, %53 ], [ %99, %98 ]
br label %102
102: ; preds = %100, %38, %35
%103 = phi i1 [ false, %38 ], [ false, %35 ], [ %101, %100 ]
br i1 %103, label %104, label %107
104: ; preds = %102
%105 = load i64, i64* %8
%106 = add nsw i64 %105, 1
store i64 %106, i64* %8
br label %35
107: ; preds = %102
%108 = load i64, i64* %8
%109 = icmp sgt i64 %108, 0
br i1 %109, label %110, label %277
110: ; preds = %107
store i32 0, i32* %10
%111 = load i64, i64* %8
switch i64 %111, label %191 [
i64 1, label %112
i64 2, label %120
i64 3, label %120
i64 4, label %131
i64 5, label %141
i64 6, label %162
]
112: ; preds = %110
%113 = load i8*, i8** %4
%114 = load i64, i64* %7
%115 = getelementptr inbounds i8, i8* %113, i64 %114
%116 = call i32 @xsingle2c(i8* %115)
%117 = trunc i32 %116 to i8
%118 = load i8*, i8** %6
%119 = getelementptr inbounds i8, i8* %118, i32 1
store i8* %119, i8** %6
store i8 %117, i8* %118
br label %191
120: ; preds = %110, %110
%121 = load i8*, i8** %4
%122 = load i64, i64* %7
%123 = load i64, i64* %8
%124 = add nsw i64 %122, %123
%125 = sub nsw i64 %124, 2
%126 = getelementptr inbounds i8, i8* %121, i64 %125
%127 = call i8* @x2c(i8* %126)
%128 = ptrtoint i8* %127 to i8
%129 = load i8*, i8** %6
%130 = getelementptr inbounds i8, i8* %129, i32 1
store i8* %130, i8** %6
store i8 %128, i8* %129
br label %191
131: ; preds = %110
%132 = load i8*, i8** %4
%133 = load i64, i64* %7
%134 = load i64, i64* %8
%135 = add nsw i64 %133, %134
%136 = sub nsw i64 %135, 2
%137 = getelementptr inbounds i8, i8* %132, i64 %136
%138 = call i8* @x2c(i8* %137)
%139 = ptrtoint i8* %138 to i8
%140 = load i8*, i8** %6
store i8 %139, i8* %140
store i32 1, i32* %10
br label %191
141: ; preds = %110
%142 = load i8*, i8** %4
%143 = load i64, i64* %7
%144 = load i64, i64* %8
%145 = add nsw i64 %143, %144
%146 = sub nsw i64 %145, 2
%147 = getelementptr inbounds i8, i8* %142, i64 %146
%148 = call i8* @x2c(i8* %147)
%149 = ptrtoint i8* %148 to i8
%150 = load i8*, i8** %6
store i8 %149, i8* %150
%151 = load i8*, i8** %4
%152 = load i64, i64* %7
%153 = getelementptr inbounds i8, i8* %151, i64 %152
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = icmp eq i32 %155, 48
br i1 %156, label %157, label %158
157: ; preds = %141
store i32 1, i32* %10
br label %161
158: ; preds = %141
%159 = load i8*, i8** %6
%160 = getelementptr inbounds i8, i8* %159, i32 1
store i8* %160, i8** %6
br label %161
161: ; preds = %158, %157
br label %191
162: ; preds = %110
%163 = load i8*, i8** %4
%164 = load i64, i64* %7
%165 = load i64, i64* %8
%166 = add nsw i64 %164, %165
%167 = sub nsw i64 %166, 2
%168 = getelementptr inbounds i8, i8* %163, i64 %167
%169 = call i8* @x2c(i8* %168)
%170 = ptrtoint i8* %169 to i8
%171 = load i8*, i8** %6
store i8 %170, i8* %171
%172 = load i8*, i8** %4
%173 = load i64, i64* %7
%174 = getelementptr inbounds i8, i8* %172, i64 %173
%175 = load i8, i8* %174
%176 = zext i8 %175 to i32
%177 = icmp eq i32 %176, 48
br i1 %177, label %178, label %187
178: ; preds = %162
%179 = load i8*, i8** %4
%180 = load i64, i64* %7
%181 = add nsw i64 %180, 1
%182 = getelementptr inbounds i8, i8* %179, i64 %181
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = icmp eq i32 %184, 48
br i1 %185, label %186, label %187
186: ; preds = %178
store i32 1, i32* %10
br label %190
187: ; preds = %178, %162
%188 = load i8*, i8** %6
%189 = getelementptr inbounds i8, i8* %188, i32 1
store i8* %189, i8** %6
br label %190
190: ; preds = %187, %186
br label %191
191: ; preds = %110, %190, %161, %131, %120, %112
%192 = load i32, i32* %10
%193 = icmp ne i32 %192, 0
br i1 %193, label %194, label %253
194: ; preds = %191
%195 = load i8*, i8** %6
%196 = load i8, i8* %195
%197 = zext i8 %196 to i32
%198 = icmp sgt i32 %197, 0
br i1 %198, label %199, label %250
199: ; preds = %194
%200 = load i8*, i8** %6
%201 = load i8, i8* %200
%202 = zext i8 %201 to i32
%203 = icmp slt i32 %202, 95
br i1 %203, label %204, label %250
204: ; preds = %199
%205 = load i8*, i8** %4
%206 = load i64, i64* %7
%207 = load i64, i64* %8
%208 = add nsw i64 %206, %207
%209 = sub nsw i64 %208, 3
%210 = getelementptr inbounds i8, i8* %205, i64 %209
%211 = load i8, i8* %210
%212 = zext i8 %211 to i32
%213 = icmp eq i32 %212, 102
br i1 %213, label %224, label %214
214: ; preds = %204
%215 = load i8*, i8** %4
%216 = load i64, i64* %7
%217 = load i64, i64* %8
%218 = add nsw i64 %216, %217
%219 = sub nsw i64 %218, 3
%220 = getelementptr inbounds i8, i8* %215, i64 %219
%221 = load i8, i8* %220
%222 = zext i8 %221 to i32
%223 = icmp eq i32 %222, 70
br i1 %223, label %224, label %250
224: ; preds = %214, %204
%225 = load i8*, i8** %4
%226 = load i64, i64* %7
%227 = load i64, i64* %8
%228 = add nsw i64 %226, %227
%229 = sub nsw i64 %228, 4
%230 = getelementptr inbounds i8, i8* %225, i64 %229
%231 = load i8, i8* %230
%232 = zext i8 %231 to i32
%233 = icmp eq i32 %232, 102
br i1 %233, label %244, label %234
234: ; preds = %224
%235 = load i8*, i8** %4
%236 = load i64, i64* %7
%237 = load i64, i64* %8
%238 = add nsw i64 %236, %237
%239 = sub nsw i64 %238, 4
%240 = getelementptr inbounds i8, i8* %235, i64 %239
%241 = load i8, i8* %240
%242 = zext i8 %241 to i32
%243 = icmp eq i32 %242, 70
br i1 %243, label %244, label %250
244: ; preds = %234, %224
%245 = load i8*, i8** %6
%246 = load i8, i8* %245
%247 = zext i8 %246 to i32
%248 = add nsw i32 %247, 32
%249 = trunc i32 %248 to i8
store i8 %249, i8* %245
br label %250
250: ; preds = %244, %234, %214, %199, %194
%251 = load i8*, i8** %6
%252 = getelementptr inbounds i8, i8* %251, i32 1
store i8* %252, i8** %6
br label %253
253: ; preds = %250, %191
%254 = load i64, i64* %7
%255 = load i64, i64* %8
%256 = add nsw i64 %254, %255
%257 = load i64, i64* %5
%258 = icmp slt i64 %256, %257
br i1 %258, label %259, label %271
259: ; preds = %253
%260 = load i8*, i8** %4
%261 = load i64, i64* %7
%262 = load i64, i64* %8
%263 = add nsw i64 %261, %262
%264 = getelementptr inbounds i8, i8* %260, i64 %263
%265 = load i8, i8* %264
%266 = call i64 @isspace(i8 zeroext %265)
%267 = icmp ne i64 %266, 0
br i1 %267, label %268, label %271
268: ; preds = %259
%269 = load i64, i64* %8
%270 = add nsw i64 %269, 1
store i64 %270, i64* %8
br label %271
271: ; preds = %268, %259, %253
%272 = load i64, i64* %9
%273 = add nsw i64 %272, 1
store i64 %273, i64* %9
%274 = load i64, i64* %8
%275 = load i64, i64* %7
%276 = add nsw i64 %275, %274
store i64 %276, i64* %7
br label %298
277: ; preds = %107
%278 = load i8*, i8** %4
%279 = load i64, i64* %7
%280 = getelementptr inbounds i8, i8* %278, i64 %279
%281 = load i8, i8* %280
%282 = zext i8 %281 to i32
%283 = icmp eq i32 %282, 10
br i1 %283, label %284, label %287
284: ; preds = %277
%285 = load i64, i64* %7
%286 = add nsw i64 %285, 1
store i64 %286, i64* %7
br label %297
287: ; preds = %277
%288 = load i8*, i8** %4
%289 = load i64, i64* %7
%290 = add nsw i64 %289, 1
store i64 %290, i64* %7
%291 = getelementptr inbounds i8, i8* %288, i64 %289
%292 = load i8, i8* %291
%293 = load i8*, i8** %6
%294 = getelementptr inbounds i8, i8* %293, i32 1
store i8* %294, i8** %6
store i8 %292, i8* %293
%295 = load i64, i64* %9
%296 = add nsw i64 %295, 1
store i64 %296, i64* %9
br label %297
297: ; preds = %287, %284
br label %298
298: ; preds = %297, %271
br label %302
299: ; preds = %27
%300 = load i64, i64* %7
%301 = add nsw i64 %300, 1
store i64 %301, i64* %7
br label %302
302: ; preds = %299, %298
br label %313
303: ; preds = %20
%304 = load i8*, i8** %4
%305 = load i64, i64* %7
%306 = add nsw i64 %305, 1
store i64 %306, i64* %7
%307 = getelementptr inbounds i8, i8* %304, i64 %305
%308 = load i8, i8* %307
%309 = load i8*, i8** %6
%310 = getelementptr inbounds i8, i8* %309, i32 1
store i8* %310, i8** %6
store i8 %308, i8* %309
%311 = load i64, i64* %9
%312 = add nsw i64 %311, 1
store i64 %312, i64* %9
br label %313
313: ; preds = %303, %302
br label %16
314: ; preds = %16
%315 = load i8*, i8** %6
store i8 0, i8* %315
%316 = load i8*, i8** %6
%317 = load i8*, i8** %4
%318 = ptrtoint i8* %316 to i64
%319 = ptrtoint i8* %317 to i64
%320 = sub i64 %318, %319
%321 = trunc i64 %320 to i32
store i32 %321, i32* %3
br label %322
322: ; preds = %314, %14
%323 = load i32, i32* %3
ret i32 %323
}

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