#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 */
struct obstack {
  int dummy;
};

/* Variables and functions */
scalar_t__ isspace(char const);
int /*<<< orphan*/ obstack_1grow(struct obstack *, char);
int /*<<< orphan*/ obstack_grow(struct obstack *, char const *, int);
const char *qu_line_grow(struct obstack *buf, const char *ptr,
                         const char *endptr, int width) {
  const char *wordend;
  int left = width;
  while (1) {
    while (isspace(*ptr) && ptr < endptr)
      ++ptr;
    wordend = ptr;
    if (*ptr == '[') {
      while (*wordend != ']' && wordend < endptr)
        ++wordend;
      if (wordend < endptr)
        ++wordend;
    } else {
      while (!isspace(*wordend) && wordend < endptr)
        ++wordend;
    }
    int wlen = wordend - ptr;
    if (left == width) {
      obstack_grow(buf, ptr, wlen);
      left -= wlen;
    } else if (wlen + 1 <= left) {
      obstack_1grow(buf, ' ');
      left -= 1;
      obstack_grow(buf, ptr, wlen);
      left -= wlen;
    } else {
      return ptr;
    }
    ptr = wordend;
    if (left <= 0 || ptr == endptr)
      return ptr;
  }
}


x86 assembly (clang, -O0):
<qu_line_grow>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1152 <qu_line_grow+0x22>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x39(%rbp)
je     117e <qu_line_grow+0x4e>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    118e <qu_line_grow+0x5e>
jmp    119f <qu_line_grow+0x6f>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1152 <qu_line_grow+0x22>
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5b,%eax
jne    121f <qu_line_grow+0xef>
jmp    11bc <qu_line_grow+0x8c>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x5d,%ecx
mov    %al,-0x3a(%rbp)
je     11df <qu_line_grow+0xaf>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    11ef <qu_line_grow+0xbf>
jmp    1200 <qu_line_grow+0xd0>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11bc <qu_line_grow+0x8c>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    121a <qu_line_grow+0xea>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1276 <qu_line_grow+0x146>
jmp    1224 <qu_line_grow+0xf4>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edi
call   1040 <isspace@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x3b(%rbp)
jne    1250 <qu_line_grow+0x120>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
mov    %al,-0x3b(%rbp)
mov    -0x3b(%rbp),%al
test   $0x1,%al
jne    1260 <qu_line_grow+0x130>
jmp    1271 <qu_line_grow+0x141>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1224 <qu_line_grow+0xf4>
jmp    1276 <qu_line_grow+0x146>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    12b0 <qu_line_grow+0x180>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x38(%rbp),%edx
call   1030 <obstack_grow@plt>
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
jmp    1308 <qu_line_grow+0x1d8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
cmp    -0x34(%rbp),%eax
jg     12f6 <qu_line_grow+0x1c6>
mov    -0x10(%rbp),%rdi
mov    $0x20,%esi
call   1050 <obstack_1grow@plt>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x38(%rbp),%edx
call   1030 <obstack_grow@plt>
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
jmp    1303 <qu_line_grow+0x1d3>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    133a <qu_line_grow+0x20a>
jmp    1308 <qu_line_grow+0x1d8>
mov    -0x30(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    1328 <qu_line_grow+0x1f8>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1335 <qu_line_grow+0x205>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    133a <qu_line_grow+0x20a>
jmp    114d <qu_line_grow+0x1d>
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qu_line_grow>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,0x8(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0x4(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %rcx,0x18(%rsp)
lea    0x1(%r13),%rcx
xor    %r15d,%r15d
nopl   0x0(%rax)
mov    %rcx,%rbp
lea    (%r15,%r13,1),%rbx
movsbl 0x0(%r13,%r15,1),%edi
call   1040 <isspace@plt>
add    $0x1,%r15
cmp    %r12,%rbx
jae    1194 <qu_line_grow+0x64>
lea    0x1(%rbp),%rcx
test   %rax,%rax
jne    1170 <qu_line_grow+0x40>
lea    (%r15,%r13,1),%r14
add    $0xffffffffffffffff,%r14
mov    -0x1(%r13,%r15,1),%al
cmp    $0x5b,%al
jne    11e0 <qu_line_grow+0xb0>
mov    %r14,%rax
cmp    %r12,%r14
setb   %cl
jae    11c9 <qu_line_grow+0x99>
lea    0x1(%rbp),%rax
cmp    %r12,%rbp
setb   %cl
jae    11c5 <qu_line_grow+0x95>
cmpb   $0x5d,0x0(%rbp)
mov    %rax,%rbp
jne    11b0 <qu_line_grow+0x80>
add    $0xffffffffffffffff,%rax
movzbl %cl,%ebx
add    %rax,%rbx
jmp    1221 <qu_line_grow+0xf1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1040 <isspace@plt>
mov    %r14,%rbx
cmp    %r12,%r14
jae    1221 <qu_line_grow+0xf1>
mov    %r14,%rbx
test   %rax,%rax
jne    1221 <qu_line_grow+0xf1>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rbx
movsbl 0x0(%rbp),%edi
call   1040 <isspace@plt>
add    $0x1,%rbp
cmp    %r12,%rbx
jae    121a <qu_line_grow+0xea>
test   %rax,%rax
je     1200 <qu_line_grow+0xd0>
add    $0xffffffffffffffff,%rbp
mov    %rbp,%rbx
mov    %r14,0x10(%rsp)
mov    $0x1,%r14d
sub    %r13d,%r14d
add    %rbx,%r14
sub    %r15,%r14
mov    0x18(%rsp),%rax
cmp    0x20(%rsp),%eax
jne    1270 <qu_line_grow+0x140>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    %r14d,%edx
call   1030 <obstack_grow@plt>
add    0x4(%rsp),%r13d
sub    %ebx,%r13d
add    %r13d,%r15d
mov    %r15d,%ecx
cmp    %r12,%rbx
jne    12ac <qu_line_grow+0x17c>
jmp    12c1 <qu_line_grow+0x191>
nopw   0x0(%rax,%rax,1)
cmp    %r14d,%eax
jle    12b9 <qu_line_grow+0x189>
mov    0x8(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x20,%esi
call   1050 <obstack_1grow@plt>
mov    %rbp,%rdi
mov    0x10(%rsp),%rsi
mov    %r14d,%edx
call   1030 <obstack_grow@plt>
mov    0x18(%rsp),%rcx
add    %r13d,%ecx
sub    %ebx,%ecx
add    %r15d,%ecx
add    $0xfffffffe,%ecx
cmp    %r12,%rbx
je     12c1 <qu_line_grow+0x191>
mov    %rbx,%r13
test   %ecx,%ecx
jg     1160 <qu_line_grow+0x30>
jmp    12c1 <qu_line_grow+0x191>
lea    (%r15,%r13,1),%rbx
add    $0xffffffffffffffff,%rbx
mov    %rbx,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.obstack = type { i32 }
define i8* @qu_line_grow(%struct.obstack* %0, i8* %1, i8* readnone %2, i32 %3) {
br label %5
5: ; preds = %63, %4
%6 = phi i8* [ %1, %4 ], [ %47, %63 ]
%7 = phi i32 [ %3, %4 ], [ %64, %63 ]
br label %8
8: ; preds = %8, %5
%9 = phi i8* [ %6, %5 ], [ %15, %8 ]
%10 = load i8, i8* %9
%11 = tail call i64 @isspace(i8 signext %10)
%12 = icmp ne i64 %11, 0
%13 = icmp ult i8* %9, %2
%14 = and i1 %13, %12
%15 = getelementptr inbounds i8, i8* %9, i64 1
br i1 %14, label %8, label %16
16: ; preds = %8
%17 = load i8, i8* %9
%18 = icmp eq i8 %17, 91
br i1 %18, label %24, label %19
19: ; preds = %16
%20 = tail call i64 @isspace(i8 signext %17)
%21 = icmp eq i64 %20, 0
%22 = icmp ult i8* %9, %2
%23 = and i1 %22, %21
br i1 %23, label %38, label %46
24: ; preds = %16
%25 = icmp ult i8* %9, %2
br i1 %25, label %26, label %33
26: ; preds = %24, %26
%27 = phi i8* [ %28, %26 ], [ %9, %24 ]
%28 = getelementptr inbounds i8, i8* %27, i64 1
%29 = load i8, i8* %28
%30 = icmp ne i8 %29, 93
%31 = icmp ult i8* %28, %2
%32 = and i1 %31, %30
br i1 %32, label %26, label %33
33: ; preds = %26, %24
%34 = phi i8* [ %9, %24 ], [ %28, %26 ]
%35 = phi i1 [ %25, %24 ], [ %31, %26 ]
%36 = zext i1 %35 to i64
%37 = getelementptr i8, i8* %34, i64 %36
br label %46
38: ; preds = %19, %38
%39 = phi i8* [ %40, %38 ], [ %9, %19 ]
%40 = getelementptr inbounds i8, i8* %39, i64 1
%41 = load i8, i8* %40
%42 = tail call i64 @isspace(i8 signext %41)
%43 = icmp eq i64 %42, 0
%44 = icmp ult i8* %40, %2
%45 = and i1 %44, %43
br i1 %45, label %38, label %46
46: ; preds = %38, %19, %33
%47 = phi i8* [ %37, %33 ], [ %9, %19 ], [ %40, %38 ]
%48 = ptrtoint i8* %47 to i64
%49 = ptrtoint i8* %9 to i64
%50 = sub i64 %48, %49
%51 = trunc i64 %50 to i32
%52 = icmp eq i32 %7, %3
br i1 %52, label %53, label %56
53: ; preds = %46
%54 = tail call i32 @obstack_grow(%struct.obstack* %0, i8* %9, i32 %51)
%55 = sub nsw i32 %3, %51
br label %63
56: ; preds = %46
%57 = icmp sgt i32 %7, %51
br i1 %57, label %58, label %68
58: ; preds = %56
%59 = tail call i32 @obstack_1grow(%struct.obstack* %0, i8 signext 32)
%60 = tail call i32 @obstack_grow(%struct.obstack* %0, i8* %9, i32 %51)
%61 = xor i32 %51, -1
%62 = add i32 %7, %61
br label %63
63: ; preds = %53, %58
%64 = phi i32 [ %55, %53 ], [ %62, %58 ]
%65 = icmp slt i32 %64, 1
%66 = icmp eq i8* %47, %2
%67 = or i1 %66, %65
br i1 %67, label %68, label %5
68: ; preds = %56, %63
%69 = phi i8* [ %47, %63 ], [ %9, %56 ]
ret i8* %69
}