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

/* Variables and functions */
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
int sfpr_str_split(char *pdata, char *array[], int num, char *sep) {
  char sepv[256];
  unsigned char c, *poffset = (unsigned char *)sep;
  int count = 0, sep_count = 0;
  if (!pdata || !array || num < 1) {
    return 0;
  }
  memset(sepv, 0, sizeof(sepv));
  if (!poffset) {
    poffset = (unsigned char *)" \t";
  }
  while (*poffset) {
    sepv[*poffset++] = 1;
  }
  sepv[0] = 2;
  sepv['\n'] = 2;
  poffset = (unsigned char *)pdata;
  while ((c = sepv[*poffset]) != 2) {
    if (c != 1)
      break;
    poffset++;
  }
  array[count++] = poffset;
  while ((c = sepv[*poffset]) != 2) {
    if (c == 1) {
      *poffset++ = 0;
      while ((c = sepv[*poffset]) != 2) {
        if (c != 1)
          break;
        poffset++;
      }
      if (c != 2)
        array[count++] = poffset;
      if (count == num) {
        break;
      }
    }
    poffset++;
  }
  return count;
}


x86 assembly (clang, -O0):
<sfpr_str_split>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x140(%rbp)
movl   $0x0,-0x144(%rbp)
movl   $0x0,-0x148(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1169 <sfpr_str_split+0x59>
cmpq   $0x0,-0x18(%rbp)
je     1169 <sfpr_str_split+0x59>
cmpl   $0x1,-0x1c(%rbp)
jge    1175 <sfpr_str_split+0x65>
movl   $0x0,-0x4(%rbp)
jmp    136f <sfpr_str_split+0x25f>
lea    -0x130(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
cmpq   $0x0,-0x140(%rbp)
jne    11a4 <sfpr_str_split+0x94>
lea    0xe63(%rip),%rax
mov    %rax,-0x140(%rbp)
jmp    11a9 <sfpr_str_split+0x99>
mov    -0x140(%rbp),%rax
cmpb   $0x0,(%rax)
je     11de <sfpr_str_split+0xce>
mov    -0x140(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x140(%rbp)
movzbl (%rax),%eax
movb   $0x1,-0x130(%rbp,%rax,1)
01
jmp    11a9 <sfpr_str_split+0x99>
movb   $0x2,-0x130(%rbp)
movb   $0x2,-0x126(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
movzbl (%rax),%eax
mov    -0x130(%rbp,%rax,1),%al
mov    %al,-0x131(%rbp)
movzbl %al,%eax
cmp    $0x2,%eax
je     1246 <sfpr_str_split+0x136>
movzbl -0x131(%rbp),%eax
cmp    $0x1,%eax
je     122f <sfpr_str_split+0x11f>
jmp    1246 <sfpr_str_split+0x136>
mov    -0x140(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x140(%rbp)
jmp    11f7 <sfpr_str_split+0xe7>
mov    -0x140(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x144(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x144(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x140(%rbp),%rax
movzbl (%rax),%eax
mov    -0x130(%rbp,%rax,1),%al
mov    %al,-0x131(%rbp)
movzbl %al,%eax
cmp    $0x2,%eax
je     1366 <sfpr_str_split+0x256>
movzbl -0x131(%rbp),%eax
cmp    $0x1,%eax
jne    134f <sfpr_str_split+0x23f>
mov    -0x140(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x140(%rbp)
movb   $0x0,(%rax)
mov    -0x140(%rbp),%rax
movzbl (%rax),%eax
mov    -0x130(%rbp,%rax,1),%al
mov    %al,-0x131(%rbp)
movzbl %al,%eax
cmp    $0x2,%eax
je     1303 <sfpr_str_split+0x1f3>
movzbl -0x131(%rbp),%eax
cmp    $0x1,%eax
je     12ec <sfpr_str_split+0x1dc>
jmp    1303 <sfpr_str_split+0x1f3>
mov    -0x140(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x140(%rbp)
jmp    12b4 <sfpr_str_split+0x1a4>
movzbl -0x131(%rbp),%eax
cmp    $0x2,%eax
je     1336 <sfpr_str_split+0x226>
mov    -0x140(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x144(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x144(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x144(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    134a <sfpr_str_split+0x23a>
jmp    1366 <sfpr_str_split+0x256>
jmp    134f <sfpr_str_split+0x23f>
mov    -0x140(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x140(%rbp)
jmp    1269 <sfpr_str_split+0x159>
mov    -0x144(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sfpr_str_split>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x108,%rsp
xor    %eax,%eax
test   %rdi,%rdi
je     11f6 <sfpr_str_split+0xe6>
mov    %rsi,%r14
test   %rsi,%rsi
je     11f6 <sfpr_str_split+0xe6>
mov    %edx,%ebp
test   %edx,%edx
jle    11f6 <sfpr_str_split+0xe6>
mov    %rcx,%r15
mov    %rdi,%rbx
mov    %rsp,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
test   %r15,%r15
lea    0xea3(%rip),%rax
cmovne %r15,%rax
mov    (%rax),%cl
test   %cl,%cl
je     1182 <sfpr_str_split+0x72>
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
movzbl %cl,%ecx
movb   $0x1,(%rsp,%rcx,1)
movzbl (%rax),%ecx
add    $0x1,%rax
test   %cl,%cl
jne    1170 <sfpr_str_split+0x60>
movb   $0x2,(%rsp)
movb   $0x2,0xa(%rsp)
add    $0xffffffffffffffff,%rbx
nop
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
cmpb   $0x1,(%rsp,%rax,1)
je     1190 <sfpr_str_split+0x80>
mov    %rbx,(%r14)
mov    $0x1,%eax
jmp    11b9 <sfpr_str_split+0xa9>
nopl   0x0(%rax,%rax,1)
cmp    $0x2,%cl
je     11f6 <sfpr_str_split+0xe6>
add    $0x1,%rbx
movzbl (%rbx),%ecx
mov    (%rsp,%rcx,1),%cl
cmp    $0x1,%cl
jne    11b0 <sfpr_str_split+0xa0>
movb   $0x0,(%rbx)
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%rbx),%ecx
add    $0x1,%rbx
movzbl (%rsp,%rcx,1),%ecx
cmp    $0x1,%cl
je     11d0 <sfpr_str_split+0xc0>
cmp    $0x2,%cl
je     11f0 <sfpr_str_split+0xe0>
movslq %eax,%rcx
add    $0x1,%eax
mov    %rbx,(%r14,%rcx,8)
cmp    %ebp,%eax
jne    11b5 <sfpr_str_split+0xa5>
mov    %ebp,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c" \09\00"
define i32 @sfpr_str_split(i8* %0, i8** writeonly %1, i32 %2, i8* %3) {
%5 = alloca [256 x i8]
%6 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
%7 = icmp eq i8* %0, null
%8 = icmp eq i8** %1, null
%9 = or i1 %7, %8
%10 = icmp slt i32 %2, 1
%11 = or i1 %9, %10
br i1 %11, label %63, label %12
12: ; preds = %4
%13 = call i32 @memset(i8* %6, i32 0, i32 256)
%14 = icmp eq i8* %3, null
%15 = select i1 %14, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %3
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 0
br i1 %17, label %26, label %18
18: ; preds = %12, %18
%19 = phi i8 [ %24, %18 ], [ %16, %12 ]
%20 = phi i8* [ %21, %18 ], [ %15, %12 ]
%21 = getelementptr inbounds i8, i8* %20, i64 1
%22 = zext i8 %19 to i64
%23 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %22
store i8 1, i8* %23
%24 = load i8, i8* %21
%25 = icmp eq i8 %24, 0
br i1 %25, label %26, label %18
26: ; preds = %18, %12
store i8 2, i8* %6
%27 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 10
store i8 2, i8* %27
br label %28
28: ; preds = %28, %26
%29 = phi i8* [ %0, %26 ], [ %35, %28 ]
%30 = load i8, i8* %29
%31 = zext i8 %30 to i64
%32 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %31
%33 = load i8, i8* %32
%34 = icmp eq i8 %33, 1
%35 = getelementptr inbounds i8, i8* %29, i64 1
br i1 %34, label %28, label %36
36: ; preds = %28
store i8* %29, i8** %1
br label %37
37: ; preds = %59, %36
%38 = phi i8* [ %29, %36 ], [ %62, %59 ]
%39 = phi i32 [ 1, %36 ], [ %61, %59 ]
%40 = load i8, i8* %38
%41 = zext i8 %40 to i64
%42 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %41
%43 = load i8, i8* %42
switch i8 %43, label %59 [
i8 2, label %63
i8 1, label %44
]
44: ; preds = %37
store i8 0, i8* %38
br label %45
45: ; preds = %45, %44
%46 = phi i8* [ %38, %44 ], [ %47, %45 ]
%47 = getelementptr inbounds i8, i8* %46, i64 1
%48 = load i8, i8* %47
%49 = zext i8 %48 to i64
%50 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %49
%51 = load i8, i8* %50
switch i8 %51, label %52 [
i8 1, label %45
i8 2, label %56
]
52: ; preds = %45
%53 = add nsw i32 %39, 1
%54 = sext i32 %39 to i64
%55 = getelementptr inbounds i8*, i8** %1, i64 %54
store i8* %47, i8** %55
br label %56
56: ; preds = %45, %52
%57 = phi i32 [ %53, %52 ], [ %39, %45 ]
%58 = icmp eq i32 %57, %2
br i1 %58, label %63, label %59
59: ; preds = %37, %56
%60 = phi i8* [ %47, %56 ], [ %38, %37 ]
%61 = phi i32 [ %57, %56 ], [ %39, %37 ]
%62 = getelementptr inbounds i8, i8* %60, i64 1
br label %37
63: ; preds = %56, %37, %4
%64 = phi i32 [ 0, %4 ], [ %39, %37 ], [ %2, %56 ]
ret i32 %64
}