#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*/ ssize_t;

/* Variables and functions */
int /*<<< orphan*/ LOG_ERR;
int atoi(char *);
int /*<<< orphan*/ hex2chr(char *);
scalar_t__ isdigit(char);
scalar_t__ isspace(char);
int /*<<< orphan*/ logIT(int /*<<< orphan*/, char *, char *);
char *strchr(char *, char);
int /*<<< orphan*/ strncpy(char *, char *, int /*<<< orphan*/);
char *strstr(char *, char *);
int parseLine(char *line, char *hex, int *hexlen, char *uSPtr,
              ssize_t uSPtrLen) {
  int token = 0;
  if (strstr(line, "WAIT") == line)
    token = 1;
  else if (strstr(line, "SEND BYTES") == line) {
    token = 5;
  } else if (strstr(line, "SEND") == line)
    token = 3;
  else if (strstr(line, "RECV") == line)
    token = 2;
  else if (strstr(line, "PAUSE") == line)
    token = 4;
  if (token) {
    char *ptr;
    ptr = strchr(line, ' ');
    if (!ptr) {
      logIT(LOG_ERR, "Parse error, kein Leerzeichen gefunden: %s", line);
    } else {
      char pString[4096];
      char *pPtr;
      while (*ptr != '\0') {
        int i;
        pPtr = pString;
        for (i = 0; i < 4096; i++)
          pPtr[i] = '\0';
        pPtr = pString;
        int endFound = 0;
        while (*++ptr == ' ')
          if (*ptr == '\0') {
            endFound = 1;
            break;
          }
        if (endFound)
          break;
        while ((*ptr != ' ') && (*ptr != '\0') && (*ptr != '\n') &&
               (*ptr != '\r')) {
          *pPtr++ = *ptr++;
        }
        if (!*pString)
          break;
        *pPtr = '\0';
        ++*hexlen;
        if (token == 4 || token == 2) {
          *hexlen = atoi(pString);
          if (token == 2) {
            pPtr = pString;
            while (*ptr && (isdigit(*ptr) || isspace(*ptr)))
              ptr++;
            strncpy(uSPtr, ptr, uSPtrLen);
          }
          return (token);
        } else if (token == 5) {
          pPtr = pString;
          while (*ptr && (isdigit(*ptr) || isspace(*ptr)))
            ptr++;
          strncpy(uSPtr, ptr, uSPtrLen);
          return (token);
        } else {
          *hex++ = hex2chr(pString);
        }
        *pString = '\0';
      }
    }
  }
  return (token);
}


x86 assembly (clang, -O0):
<parseLine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1060,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe4f(%rip),%rsi
call   10a0 <strstr@plt>
cmp    -0x10(%rbp),%rax
jne    11cc <parseLine+0x4c>
movl   $0x1,-0x30(%rbp)
jmp    1273 <parseLine+0xf3>
mov    -0x10(%rbp),%rdi
lea    0xe2e(%rip),%rsi
call   10a0 <strstr@plt>
cmp    -0x10(%rbp),%rax
jne    11f2 <parseLine+0x72>
movl   $0x5,-0x30(%rbp)
jmp    126e <parseLine+0xee>
mov    -0x10(%rbp),%rdi
lea    0xe13(%rip),%rsi
call   10a0 <strstr@plt>
cmp    -0x10(%rbp),%rax
jne    1218 <parseLine+0x98>
movl   $0x3,-0x30(%rbp)
jmp    1269 <parseLine+0xe9>
mov    -0x10(%rbp),%rdi
lea    0xdf2(%rip),%rsi
call   10a0 <strstr@plt>
cmp    -0x10(%rbp),%rax
jne    123e <parseLine+0xbe>
movl   $0x2,-0x30(%rbp)
jmp    1264 <parseLine+0xe4>
mov    -0x10(%rbp),%rdi
lea    0xdd1(%rip),%rsi
call   10a0 <strstr@plt>
cmp    -0x10(%rbp),%rax
jne    125f <parseLine+0xdf>
movl   $0x4,-0x30(%rbp)
jmp    1264 <parseLine+0xe4>
jmp    1269 <parseLine+0xe9>
jmp    126e <parseLine+0xee>
jmp    1273 <parseLine+0xf3>
cmpl   $0x0,-0x30(%rbp)
je     1618 <parseLine+0x498>
mov    -0x10(%rbp),%rdi
mov    $0x20,%esi
call   1050 <strchr@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    12b8 <parseLine+0x138>
mov    0x2d37(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
lea    0xd72(%rip),%rsi
call   1090 <logIT@plt>
jmp    1613 <parseLine+0x493>
jmp    12bd <parseLine+0x13d>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     160e <parseLine+0x48e>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
movl   $0x0,-0x104c(%rbp)
cmpl   $0x1000,-0x104c(%rbp)
jge    131b <parseLine+0x19b>
mov    -0x1048(%rbp),%rax
movslq -0x104c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x104c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104c(%rbp)
jmp    12e5 <parseLine+0x165>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
movl   $0x0,-0x1050(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movsbl 0x1(%rax),%eax
cmp    $0x20,%eax
jne    1373 <parseLine+0x1f3>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    136e <parseLine+0x1ee>
movl   $0x1,-0x1050(%rbp)
jmp    1373 <parseLine+0x1f3>
jmp    1333 <parseLine+0x1b3>
cmpl   $0x0,-0x1050(%rbp)
je     1385 <parseLine+0x205>
jmp    160e <parseLine+0x48e>
jmp    138a <parseLine+0x20a>
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x1051(%rbp)
je     13e5 <parseLine+0x265>
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x1051(%rbp)
je     13e5 <parseLine+0x265>
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x1051(%rbp)
je     13e5 <parseLine+0x265>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xd,%eax
setne  %al
mov    %al,-0x1051(%rbp)
mov    -0x1051(%rbp),%al
test   $0x1,%al
jne    13f8 <parseLine+0x278>
jmp    1425 <parseLine+0x2a5>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x1048(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x1048(%rbp)
mov    %cl,(%rax)
jmp    138a <parseLine+0x20a>
cmpb   $0x0,-0x1040(%rbp)
jne    1437 <parseLine+0x2b7>
jmp    160e <parseLine+0x48e>
mov    -0x1048(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
cmpl   $0x4,-0x30(%rbp)
je     1460 <parseLine+0x2e0>
cmpl   $0x2,-0x30(%rbp)
jne    1529 <parseLine+0x3a9>
lea    -0x1040(%rbp),%rdi
call   1080 <atoi@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0x2,-0x30(%rbp)
jne    151e <parseLine+0x39e>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x1052(%rbp)
je     14ea <parseLine+0x36a>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x1053(%rbp)
jne    14de <parseLine+0x35e>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x1053(%rbp)
mov    -0x1053(%rbp),%al
mov    %al,-0x1052(%rbp)
mov    -0x1052(%rbp),%al
test   $0x1,%al
jne    14fd <parseLine+0x37d>
jmp    150e <parseLine+0x38e>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    148c <parseLine+0x30c>
mov    -0x28(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x2c(%rbp),%edx
call   1030 <strncpy@plt>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    161e <parseLine+0x49e>
cmpl   $0x5,-0x30(%rbp)
jne    15de <parseLine+0x45e>
lea    -0x1040(%rbp),%rax
mov    %rax,-0x1048(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x1054(%rbp)
je     159f <parseLine+0x41f>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x1055(%rbp)
jne    1593 <parseLine+0x413>
mov    -0x38(%rbp),%rax
movsbl (%rax),%edi
call   1060 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x1055(%rbp)
mov    -0x1055(%rbp),%al
mov    %al,-0x1054(%rbp)
mov    -0x1054(%rbp),%al
test   $0x1,%al
jne    15b2 <parseLine+0x432>
jmp    15c3 <parseLine+0x443>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1541 <parseLine+0x3c1>
mov    -0x28(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x2c(%rbp),%edx
call   1030 <strncpy@plt>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    161e <parseLine+0x49e>
lea    -0x1040(%rbp),%rdi
call   1070 <hex2chr@plt>
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    1602 <parseLine+0x482>
movb   $0x0,-0x1040(%rbp)
jmp    12bd <parseLine+0x13d>
jmp    1613 <parseLine+0x493>
jmp    1618 <parseLine+0x498>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1060,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parseLine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1028,%rsp
mov    %r8d,%r12d
mov    %rcx,%r13
mov    %rdx,0x18(%rsp)
mov    %rsi,%rbp
mov    %rdi,%r14
lea    0xe47(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     123d <parseLine+0xad>
lea    0xe37(%rip),%rsi
mov    $0xa,%edx
mov    %r14,%rdi
call   1040 <strncmp@plt>
test   %eax,%eax
je     1246 <parseLine+0xb6>
lea    0xe2a(%rip),%rsi
mov    $0x4,%edx
mov    %r14,%rdi
call   1040 <strncmp@plt>
test   %eax,%eax
je     1260 <parseLine+0xd0>
lea    0xe17(%rip),%rsi
mov    $0x4,%edx
mov    %r14,%rdi
call   1040 <strncmp@plt>
xor    %ebx,%ebx
test   %eax,%eax
je     1382 <parseLine+0x1f2>
lea    0xdfe(%rip),%rsi
mov    $0x5,%edx
mov    %r14,%rdi
call   1040 <strncmp@plt>
test   %eax,%eax
jne    136e <parseLine+0x1de>
movl   $0x4,(%rsp)
mov    $0x1,%r15b
jmp    126a <parseLine+0xda>
movl   $0x1,(%rsp)
jmp    1267 <parseLine+0xd7>
movl   $0x5,(%rsp)
mov    $0x1,%al
mov    %eax,0x8(%rsp)
xor    %r15d,%r15d
movl   $0x0,0x4(%rsp)
jmp    127a <parseLine+0xea>
movl   $0x3,(%rsp)
xor    %r15d,%r15d
movl   $0x0,0x4(%rsp)
movl   $0x0,0x8(%rsp)
mov    %r14,%rdi
mov    $0x20,%esi
call   1060 <strchr@plt>
test   %rax,%rax
je     1353 <parseLine+0x1c3>
mov    %rax,%rbx
mov    %r13,0x10(%rsp)
mov    %r12d,0xc(%rsp)
cmpb   $0x0,(%rax)
je     136b <parseLine+0x1db>
or     0x4(%rsp),%r15b
lea    0x20(%rsp),%r14
movabs $0x100002401,%r13
nopw   0x0(%rax,%rax,1)
mov    $0x1000,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
nop
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
cmp    $0x20,%al
je     12d0 <parseLine+0x140>
xor    %r12d,%r12d
jmp    12ff <parseLine+0x16f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %al,0x20(%rsp,%r12,1)
movzbl 0x1(%rbx,%r12,1),%eax
add    $0x1,%r12
cmp    $0x20,%al
ja     12f0 <parseLine+0x160>
movzbl %al,%ecx
bt     %rcx,%r13
jae    12f0 <parseLine+0x160>
cmpb   $0x0,0x20(%rsp)
je     136b <parseLine+0x1db>
movb   $0x0,0x20(%rsp,%r12,1)
mov    0x18(%rsp),%rax
addl   $0x1,(%rax)
test   %r15b,%r15b
jne    1397 <parseLine+0x207>
cmpb   $0x0,0x8(%rsp)
jne    13fb <parseLine+0x26b>
add    %r12,%rbx
mov    %r14,%rdi
call   1090 <hex2chr@plt>
mov    %al,0x0(%rbp)
add    $0x1,%rbp
movb   $0x0,0x20(%rsp)
cmpb   $0x0,(%rbx)
jne    12c0 <parseLine+0x130>
jmp    136b <parseLine+0x1db>
mov    0x2c7e(%rip),%rax
mov    (%rax),%edi
lea    0xcbd(%rip),%rsi
mov    %r14,%rdx
call   10b0 <logIT@plt>
mov    (%rsp),%ebx
mov    %ebx,%eax
add    $0x1028,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movl   $0x2,(%rsp)
mov    $0x1,%al
mov    %eax,0x4(%rsp)
xor    %r15d,%r15d
jmp    1272 <parseLine+0xe2>
lea    0x20(%rsp),%rdi
call   10a0 <atoi@plt>
mov    0x18(%rsp),%rcx
mov    %eax,(%rcx)
cmpb   $0x0,0x4(%rsp)
mov    0x10(%rsp),%r15
je     136b <parseLine+0x1db>
add    %r12,%rbx
mov    (%rbx),%al
test   %al,%al
je     1455 <parseLine+0x2c5>
mov    0xc(%rsp),%r14d
jmp    13dc <parseLine+0x24c>
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
je     13f6 <parseLine+0x266>
movsbl %al,%edi
call   1050 <isdigit@plt>
test   %rax,%rax
jne    13d0 <parseLine+0x240>
movsbl (%rbx),%edi
call   1080 <isspace@plt>
test   %rax,%rax
jne    13d0 <parseLine+0x240>
mov    %rbx,%rbp
jmp    145d <parseLine+0x2cd>
lea    (%rbx,%r12,1),%rbp
mov    (%rbx,%r12,1),%al
mov    $0x5,%ebx
test   %al,%al
je     1449 <parseLine+0x2b9>
mov    0xc(%rsp),%r14d
mov    0x10(%rsp),%r15
jmp    142c <parseLine+0x29c>
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%rbp),%eax
add    $0x1,%rbp
test   %al,%al
je     1460 <parseLine+0x2d0>
movsbl %al,%edi
call   1050 <isdigit@plt>
test   %rax,%rax
jne    1420 <parseLine+0x290>
movsbl 0x0(%rbp),%edi
call   1080 <isspace@plt>
test   %rax,%rax
jne    1420 <parseLine+0x290>
jmp    1460 <parseLine+0x2d0>
mov    0xc(%rsp),%r14d
mov    0x10(%rsp),%r15
jmp    1460 <parseLine+0x2d0>
mov    %rbx,%rbp
mov    0xc(%rsp),%r14d
mov    (%rsp),%ebx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r14d,%edx
call   1030 <strncpy@plt>
jmp    136e <parseLine+0x1de>

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

LLVM IR (-O2):
@.str = [5 x i8] c"WAIT\00"
@.str.1 = [11 x i8] c"SEND BYTES\00"
@.str.2 = [5 x i8] c"SEND\00"
@.str.3 = [5 x i8] c"RECV\00"
@.str.4 = [6 x i8] c"PAUSE\00"
@LOG_ERR = global i32 0
@.str.5 = [43 x i8] c"Parse error, kein Leerzeichen gefunden: %s\00"
define i32 @parseLine(i8* %0, i8* nocapture writeonly %1, i32* nocapture %2, i8* %3, i32 %4) {
%6 = alloca [4096 x i8]
%7 = getelementptr inbounds [4096 x i8], [4096 x i8]* %6, i64 0, i64 0
%8 = tail call i32 @strncmp(i8* dereferenceable(1) %0, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i64 4)
%9 = icmp eq i32 %8, 0
br i1 %9, label %22, label %10
10: ; preds = %5
%11 = tail call i32 @strncmp(i8* dereferenceable(1) %0, i8* dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0), i64 10)
%12 = icmp eq i32 %11, 0
br i1 %12, label %22, label %13
13: ; preds = %10
%14 = tail call i32 @strncmp(i8* dereferenceable(1) %0, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i64 4)
%15 = icmp eq i32 %14, 0
br i1 %15, label %22, label %16
16: ; preds = %13
%17 = tail call i32 @strncmp(i8* dereferenceable(1) %0, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i64 4)
%18 = icmp eq i32 %17, 0
br i1 %18, label %22, label %19
19: ; preds = %16
%20 = tail call i32 @strncmp(i8* dereferenceable(1) %0, i8* dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i64 5)
%21 = icmp eq i32 %20, 0
br i1 %21, label %22, label %108
22: ; preds = %19, %5, %10, %13, %16
%23 = phi i1 [ false, %16 ], [ false, %13 ], [ false, %10 ], [ false, %5 ], [ true, %19 ]
%24 = phi i1 [ true, %16 ], [ false, %13 ], [ false, %10 ], [ false, %5 ], [ false, %19 ]
%25 = phi i1 [ false, %16 ], [ false, %13 ], [ true, %10 ], [ false, %5 ], [ false, %19 ]
%26 = phi i32 [ 2, %16 ], [ 3, %13 ], [ 5, %10 ], [ 1, %5 ], [ 4, %19 ]
%27 = tail call i8* @strchr(i8* dereferenceable(1) %0, i8 signext 32)
%28 = icmp eq i8* %27, null
br i1 %28, label %29, label %32
29: ; preds = %22
%30 = load i32, i32* @LOG_ERR
%31 = tail call i32 @logIT(i32 %30, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0), i8* %0)
br label %108
32: ; preds = %22
%33 = getelementptr inbounds [4096 x i8], [4096 x i8]* %6, i64 0, i64 0
%34 = load i8, i8* %27
%35 = icmp eq i8 %34, 0
br i1 %35, label %101, label %36
36: ; preds = %32
%37 = or i1 %23, %24
br label %38
38: ; preds = %36, %95
%39 = phi i8* [ %27, %36 ], [ %48, %95 ]
%40 = phi i8* [ %1, %36 ], [ %98, %95 ]
br label %41
41: ; preds = %38, %41
%42 = phi i8* [ %43, %41 ], [ %39, %38 ]
%43 = getelementptr inbounds i8, i8* %42, i64 1
%44 = load i8, i8* %43
%45 = icmp eq i8 %44, 32
br i1 %45, label %41, label %46
46: ; preds = %41, %50
%47 = phi i8 [ %53, %50 ], [ %44, %41 ]
%48 = phi i8* [ %51, %50 ], [ %43, %41 ]
%49 = phi i8* [ %52, %50 ], [ %33, %41 ]
switch i8 %47, label %50 [
i8 32, label %54
i8 0, label %54
i8 10, label %54
i8 13, label %54
]
50: ; preds = %46
%51 = getelementptr inbounds i8, i8* %48, i64 1
%52 = getelementptr inbounds i8, i8* %49, i64 1
store i8 %47, i8* %49
%53 = load i8, i8* %51
br label %46
54: ; preds = %46, %46, %46, %46
%55 = load i8, i8* %33
%56 = icmp eq i8 %55, 0
br i1 %56, label %101, label %57
57: ; preds = %54
store i8 0, i8* %49
%58 = load i32, i32* %2
%59 = add nsw i32 %58, 1
store i32 %59, i32* %2
br i1 %37, label %60, label %78
60: ; preds = %57
%61 = call i32 @atoi(i8* %33)
store i32 %61, i32* %2
br i1 %24, label %62, label %106
62: ; preds = %60
%63 = load i8, i8* %48
%64 = icmp eq i8 %63, 0
br i1 %64, label %102, label %65
65: ; preds = %62, %74
%66 = phi i8 [ %76, %74 ], [ %63, %62 ]
%67 = phi i8* [ %75, %74 ], [ %48, %62 ]
%68 = call i64 @isdigit(i8 signext %66)
%69 = icmp eq i64 %68, 0
br i1 %69, label %70, label %74
70: ; preds = %65
%71 = load i8, i8* %67
%72 = call i64 @isspace(i8 signext %71)
%73 = icmp eq i64 %72, 0
br i1 %73, label %102, label %74
74: ; preds = %65, %70
%75 = getelementptr inbounds i8, i8* %67, i64 1
%76 = load i8, i8* %75
%77 = icmp eq i8 %76, 0
br i1 %77, label %102, label %65
78: ; preds = %57
br i1 %25, label %79, label %95
79: ; preds = %78
%80 = load i8, i8* %48
%81 = icmp eq i8 %80, 0
br i1 %81, label %102, label %82
82: ; preds = %79, %91
%83 = phi i8 [ %93, %91 ], [ %80, %79 ]
%84 = phi i8* [ %92, %91 ], [ %48, %79 ]
%85 = call i64 @isdigit(i8 signext %83)
%86 = icmp eq i64 %85, 0
br i1 %86, label %87, label %91
87: ; preds = %82
%88 = load i8, i8* %84
%89 = call i64 @isspace(i8 signext %88)
%90 = icmp eq i64 %89, 0
br i1 %90, label %102, label %91
91: ; preds = %82, %87
%92 = getelementptr inbounds i8, i8* %84, i64 1
%93 = load i8, i8* %92
%94 = icmp eq i8 %93, 0
br i1 %94, label %102, label %82
95: ; preds = %78
%96 = call i32 @hex2chr(i8* %33)
%97 = trunc i32 %96 to i8
%98 = getelementptr inbounds i8, i8* %40, i64 1
store i8 %97, i8* %40
store i8 0, i8* %33
%99 = load i8, i8* %48
%100 = icmp eq i8 %99, 0
br i1 %100, label %101, label %38
101: ; preds = %54, %95, %32
br label %108
102: ; preds = %91, %87, %74, %70, %79, %62
%103 = phi i8* [ %48, %62 ], [ %48, %79 ], [ %75, %74 ], [ %67, %70 ], [ %92, %91 ], [ %84, %87 ]
%104 = phi i32 [ %26, %62 ], [ 5, %79 ], [ %26, %70 ], [ %26, %74 ], [ 5, %87 ], [ 5, %91 ]
%105 = call i32 @strncpy(i8* %3, i8* %103, i32 %4)
br label %106
106: ; preds = %102, %60
%107 = phi i32 [ %26, %60 ], [ %104, %102 ]
br label %108
108: ; preds = %29, %101, %19, %106
%109 = phi i32 [ %107, %106 ], [ 0, %19 ], [ %26, %101 ], [ %26, %29 ]
ret i32 %109
}