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

/* Variables and functions */
scalar_t__ isspace(char);
int /*<<< orphan*/ memcpy(char *, char *, int);
char *strchr(char *, char);
char *strdup(char *);
int strlen(char *);
char *strstr(char *, char *);
char *extract_address(char *s) {
  char *p1, *p2, *p3;
  char buf[100];
  if (strlen(s) > sizeof(buf) - 1)
    return strdup(s);
  p1 = strstr(s, "&lt;");
  if (p1) {
    p1 += 4;
    p2 = strstr(p1, "&gt;");
    if (p2) {
      while ((p3 = strstr(p1, "&lt;")) && (p3 < p2)) {
        p1 = p3 + 4;
      }
      memcpy(buf, p1, p2 - p1);
      buf[(int)(p2 - p1)] = 0;
      return strdup(buf);
    }
  }
  p1 = strstr(s, "<");
  if (p1) {
    p1 += 1;
    p2 = strstr(p1, ">");
    if (p2) {
      while ((p3 = strstr(p1, ">")) && (p3 < p2)) {
        p1 = p3 + 1;
      }
      memcpy(buf, p1, p2 - p1);
      buf[(int)(p2 - p1)] = 0;
      return strdup(buf);
    }
  }
  p1 = strchr(s, '@');
  if (p1) {
    while (p1 > s && !isspace(*p1))
      p1--;
    if (isspace(*p1))
      p1++;
    p2 = p1 + 1;
    while (*p2 && !isspace(*p2))
      p2++;
    memcpy(buf, p1, p2 - p1);
    buf[(int)(p2 - p1)] = 0;
    return strdup(buf);
  }
  p1 = s;
  while (*p1 && isspace(*p1))
    p1++;
  p2 = p1;
  while (*p2 && !isspace(*p2))
    p2++;
  memcpy(buf, p1, p2 - p1);
  buf[(int)(p2 - p1)] = 0;
  return strdup(buf);
}


x86 assembly (clang, -O0):
<extract_address>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
cltq
cmp    $0x63,%rax
jbe    1196 <extract_address+0x36>
mov    -0x10(%rbp),%rdi
call   1070 <strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    15c9 <extract_address+0x469>
mov    -0x10(%rbp),%rdi
lea    0xe5f(%rip),%rsi
call   1080 <strstr@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     128f <extract_address+0x12f>
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
lea    0xe39(%rip),%rsi
call   1080 <strstr@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     128a <extract_address+0x12a>
jmp    11e5 <extract_address+0x85>
mov    -0x18(%rbp),%rdi
lea    0xe10(%rip),%rsi
call   1080 <strstr@plt>
mov    %rax,%rcx
mov    %rcx,-0x28(%rbp)
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x91(%rbp)
je     121f <extract_address+0xbf>
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
mov    %al,-0x91(%rbp)
mov    -0x91(%rbp),%al
test   $0x1,%al
jne    1232 <extract_address+0xd2>
jmp    1243 <extract_address+0xe3>
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
jmp    11e5 <extract_address+0x85>
lea    -0x90(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
cltq
movb   $0x0,-0x90(%rbp,%rax,1)
lea    -0x90(%rbp),%rdi
call   1070 <strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    15c9 <extract_address+0x469>
jmp    128f <extract_address+0x12f>
mov    -0x10(%rbp),%rdi
lea    0xd70(%rip),%rsi
call   1080 <strstr@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1388 <extract_address+0x228>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
lea    0xd47(%rip),%rsi
call   1080 <strstr@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     1383 <extract_address+0x223>
jmp    12de <extract_address+0x17e>
mov    -0x18(%rbp),%rdi
lea    0xd23(%rip),%rsi
call   1080 <strstr@plt>
mov    %rax,%rcx
mov    %rcx,-0x28(%rbp)
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x92(%rbp)
je     1318 <extract_address+0x1b8>
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
mov    %al,-0x92(%rbp)
mov    -0x92(%rbp),%al
test   $0x1,%al
jne    132b <extract_address+0x1cb>
jmp    133c <extract_address+0x1dc>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    12de <extract_address+0x17e>
lea    -0x90(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
cltq
movb   $0x0,-0x90(%rbp,%rax,1)
lea    -0x90(%rbp),%rdi
call   1070 <strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    15c9 <extract_address+0x469>
jmp    1388 <extract_address+0x228>
mov    -0x10(%rbp),%rdi
mov    $0x40,%esi
call   1040 <strchr@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     14cb <extract_address+0x36b>
jmp    13aa <extract_address+0x24a>
mov    -0x18(%rbp),%rcx
xor    %eax,%eax
cmp    -0x10(%rbp),%rcx
mov    %al,-0x93(%rbp)
jbe    13db <extract_address+0x27b>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x93(%rbp)
mov    -0x93(%rbp),%al
test   $0x1,%al
jne    13ee <extract_address+0x28e>
jmp    13ff <extract_address+0x29f>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    13aa <extract_address+0x24a>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
je     1421 <extract_address+0x2c1>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x94(%rbp)
je     1460 <extract_address+0x300>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x94(%rbp)
mov    -0x94(%rbp),%al
test   $0x1,%al
jne    1473 <extract_address+0x313>
jmp    1484 <extract_address+0x324>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    142d <extract_address+0x2cd>
lea    -0x90(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
cltq
movb   $0x0,-0x90(%rbp,%rax,1)
lea    -0x90(%rbp),%rdi
call   1070 <strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    15c9 <extract_address+0x469>
mov    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x95(%rbp)
je     1504 <extract_address+0x3a4>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x95(%rbp)
mov    -0x95(%rbp),%al
test   $0x1,%al
jne    1517 <extract_address+0x3b7>
jmp    1528 <extract_address+0x3c8>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    14d3 <extract_address+0x373>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x96(%rbp)
je     1563 <extract_address+0x403>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x96(%rbp)
mov    -0x96(%rbp),%al
test   $0x1,%al
jne    1576 <extract_address+0x416>
jmp    1587 <extract_address+0x427>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1530 <extract_address+0x3d0>
lea    -0x90(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
cltq
movb   $0x0,-0x90(%rbp,%rax,1)
lea    -0x90(%rbp),%rdi
call   1070 <strdup@plt>
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<extract_address>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdi,%r14
call   1030 <strlen@plt>
cmp    $0x64,%eax
jb     118b <extract_address+0x2b>
mov    %r14,%rdi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1070 <strdup@plt>
lea    0xe6e(%rip),%rsi
mov    %r14,%rdi
call   1080 <strstr@plt>
test   %rax,%rax
je     11ee <extract_address+0x8e>
mov    %rax,%r12
add    $0x4,%r12
lea    0xe58(%rip),%rsi
mov    %r12,%rdi
call   1080 <strstr@plt>
test   %rax,%rax
je     11ee <extract_address+0x8e>
mov    %rax,%r15
lea    0xe3c(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rbx
mov    %r12,%rdi
mov    %r14,%rsi
call   1080 <strstr@plt>
test   %rax,%rax
je     123e <extract_address+0xde>
lea    0x4(%rax),%r12
cmp    %r15,%rax
jb     11d0 <extract_address+0x70>
jmp    123e <extract_address+0xde>
mov    %r14,%rdi
mov    $0x3c,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1261 <extract_address+0x101>
mov    %rax,%r12
add    $0x1,%r12
mov    %r12,%rdi
mov    $0x3e,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1261 <extract_address+0x101>
mov    %rax,%r15
nopl   0x0(%rax)
mov    %r12,%rbx
mov    %r12,%rdi
mov    $0x3e,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     123e <extract_address+0xde>
lea    0x1(%rax),%r12
cmp    %r15,%rax
jb     1220 <extract_address+0xc0>
sub    %rbx,%r15
mov    %rsp,%r14
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
call   1060 <memcpy@plt>
movslq %r15d,%rax
movb   $0x0,(%rsp,%rax,1)
mov    %r14,%rdi
jmp    134f <extract_address+0x1ef>
mov    %r14,%rdi
mov    $0x40,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     1302 <extract_address+0x1a2>
mov    %rax,%r15
cmp    %r14,%r15
jbe    1297 <extract_address+0x137>
nop
movsbl (%r15),%edi
call   1050 <isspace@plt>
test   %rax,%rax
jne    1297 <extract_address+0x137>
add    $0xffffffffffffffff,%r15
cmp    %r14,%r15
ja     1280 <extract_address+0x120>
movabs $0x100000000,%r14
movsbl (%r15),%edi
call   1050 <isspace@plt>
cmp    $0x1,%rax
sbb    $0xffffffffffffffff,%r15
mov    $0x1,%ecx
mov    %r14,%rdx
nopw   0x0(%rax,%rax,1)
mov    %rdx,%r12
mov    %rcx,%rbx
movzbl (%r15,%rcx,1),%eax
test   %al,%al
je     12e4 <extract_address+0x184>
movsbl %al,%edi
call   1050 <isspace@plt>
lea    (%r12,%r14,1),%rdx
lea    0x1(%rbx),%rcx
test   %rax,%rax
je     12c0 <extract_address+0x160>
mov    %rsp,%r14
mov    %r14,%rdi
mov    %r15,%rsi
mov    %ebx,%edx
call   1060 <memcpy@plt>
sar    $0x20,%r12
movb   $0x0,(%rsp,%r12,1)
mov    %r14,%rdi
jmp    134f <extract_address+0x1ef>
mov    (%r14),%al
test   %al,%al
je     132f <extract_address+0x1cf>
nopl   0x0(%rax)
movsbl %al,%edi
call   1050 <isspace@plt>
test   %rax,%rax
je     1360 <extract_address+0x200>
movzbl 0x1(%r14),%eax
add    $0x1,%r14
mov    %r14,%rbx
test   %al,%al
jne    1310 <extract_address+0x1b0>
jmp    1332 <extract_address+0x1d2>
mov    %r14,%rbx
sub    %r14,%rbx
mov    %rsp,%r15
mov    %r15,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1060 <memcpy@plt>
movslq %ebx,%rax
movb   $0x0,(%rsp,%rax,1)
mov    %r15,%rdi
call   1070 <strdup@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    (%r14),%al
mov    %r14,%rbx
test   %al,%al
je     1332 <extract_address+0x1d2>
nopw   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1050 <isspace@plt>
test   %rax,%rax
jne    1332 <extract_address+0x1d2>
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
test   %al,%al
jne    1370 <extract_address+0x210>
jmp    1332 <extract_address+0x1d2>

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

LLVM IR (-O2):
@.str = [5 x i8] c"&lt;\00"
@.str.1 = [5 x i8] c"&gt;\00"
define i8* @extract_address(i8* %0) {
%2 = alloca [100 x i8]
%3 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 0
%4 = tail call i32 @strlen(i8* %0)
%5 = icmp ugt i32 %4, 99
br i1 %5, label %6, label %8
6: ; preds = %1
%7 = tail call i8* @strdup(i8* %0)
br label %130
8: ; preds = %1
%9 = tail call i8* @strstr(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%10 = icmp eq i8* %9, null
br i1 %10, label %32, label %11
11: ; preds = %8
%12 = getelementptr inbounds i8, i8* %9, i64 4
%13 = tail call i8* @strstr(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%14 = icmp eq i8* %13, null
br i1 %14, label %32, label %15
15: ; preds = %11, %15
%16 = phi i8* [ %21, %15 ], [ %12, %11 ]
%17 = tail call i8* @strstr(i8* %16, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%18 = icmp ne i8* %17, null
%19 = icmp ult i8* %17, %13
%20 = select i1 %18, i1 %19, i1 false
%21 = getelementptr inbounds i8, i8* %17, i64 4
br i1 %20, label %15, label %22
22: ; preds = %15
%23 = ptrtoint i8* %13 to i64
%24 = ptrtoint i8* %16 to i64
%25 = sub i64 %23, %24
%26 = trunc i64 %25 to i32
%27 = call i32 @memcpy(i8* %3, i8* %16, i32 %26)
%28 = shl i64 %25, 32
%29 = ashr exact i64 %28, 32
%30 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %29
store i8 0, i8* %30
%31 = call i8* @strdup(i8* %3)
br label %130
32: ; preds = %11, %8
%33 = tail call i8* bitcast (i8* (i8*, i8)* @strchr to i8* (i8*, i32)*)(i8* %0, i32 60)
%34 = icmp eq i8* %33, null
br i1 %34, label %56, label %35
35: ; preds = %32
%36 = getelementptr inbounds i8, i8* %33, i64 1
%37 = tail call i8* bitcast (i8* (i8*, i8)* @strchr to i8* (i8*, i32)*)(i8* %36, i32 62)
%38 = icmp eq i8* %37, null
br i1 %38, label %56, label %39
39: ; preds = %35, %39
%40 = phi i8* [ %45, %39 ], [ %36, %35 ]
%41 = tail call i8* bitcast (i8* (i8*, i8)* @strchr to i8* (i8*, i32)*)(i8* %40, i32 62)
%42 = icmp ne i8* %41, null
%43 = icmp ult i8* %41, %37
%44 = select i1 %42, i1 %43, i1 false
%45 = getelementptr inbounds i8, i8* %41, i64 1
br i1 %44, label %39, label %46
46: ; preds = %39
%47 = ptrtoint i8* %37 to i64
%48 = ptrtoint i8* %40 to i64
%49 = sub i64 %47, %48
%50 = trunc i64 %49 to i32
%51 = call i32 @memcpy(i8* %3, i8* %40, i32 %50)
%52 = shl i64 %49, 32
%53 = ashr exact i64 %52, 32
%54 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %53
store i8 0, i8* %54
%55 = call i8* @strdup(i8* %3)
br label %130
56: ; preds = %35, %32
%57 = tail call i8* @strchr(i8* dereferenceable(1) %0, i8 signext 64)
%58 = icmp eq i8* %57, null
br i1 %58, label %61, label %59
59: ; preds = %56
%60 = icmp ugt i8* %57, %0
br i1 %60, label %64, label %72
61: ; preds = %56
%62 = load i8, i8* %0
%63 = icmp eq i8 %62, 0
br i1 %63, label %118, label %97
64: ; preds = %59, %69
%65 = phi i8* [ %70, %69 ], [ %57, %59 ]
%66 = load i8, i8* %65
%67 = tail call i64 @isspace(i8 signext %66)
%68 = icmp eq i64 %67, 0
br i1 %68, label %69, label %72
69: ; preds = %64
%70 = getelementptr inbounds i8, i8* %65, i64 -1
%71 = icmp ugt i8* %70, %0
br i1 %71, label %64, label %72
72: ; preds = %64, %69, %59
%73 = phi i8* [ %57, %59 ], [ %70, %69 ], [ %65, %64 ]
%74 = load i8, i8* %73
%75 = tail call i64 @isspace(i8 signext %74)
%76 = icmp ne i64 %75, 0
%77 = zext i1 %76 to i64
%78 = getelementptr i8, i8* %73, i64 %77
br label %79
79: ; preds = %84, %72
%80 = phi i8* [ %78, %72 ], [ %81, %84 ]
%81 = getelementptr inbounds i8, i8* %80, i64 1
%82 = load i8, i8* %81
%83 = icmp eq i8 %82, 0
br i1 %83, label %87, label %84
84: ; preds = %79
%85 = tail call i64 @isspace(i8 signext %82)
%86 = icmp eq i64 %85, 0
br i1 %86, label %79, label %87
87: ; preds = %79, %84
%88 = ptrtoint i8* %81 to i64
%89 = ptrtoint i8* %78 to i64
%90 = sub i64 %88, %89
%91 = trunc i64 %90 to i32
%92 = call i32 @memcpy(i8* %3, i8* %78, i32 %91)
%93 = shl i64 %90, 32
%94 = ashr exact i64 %93, 32
%95 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %94
store i8 0, i8* %95
%96 = call i8* @strdup(i8* %3)
br label %130
97: ; preds = %61, %102
%98 = phi i8 [ %104, %102 ], [ %62, %61 ]
%99 = phi i8* [ %103, %102 ], [ %0, %61 ]
%100 = tail call i64 @isspace(i8 signext %98)
%101 = icmp eq i64 %100, 0
br i1 %101, label %106, label %102
102: ; preds = %97
%103 = getelementptr inbounds i8, i8* %99, i64 1
%104 = load i8, i8* %103
%105 = icmp eq i8 %104, 0
br i1 %105, label %118, label %97
106: ; preds = %97
%107 = load i8, i8* %99
%108 = icmp eq i8 %107, 0
br i1 %108, label %118, label %109
109: ; preds = %106, %114
%110 = phi i8 [ %116, %114 ], [ %107, %106 ]
%111 = phi i8* [ %115, %114 ], [ %99, %106 ]
%112 = tail call i64 @isspace(i8 signext %110)
%113 = icmp eq i64 %112, 0
br i1 %113, label %114, label %118
114: ; preds = %109
%115 = getelementptr inbounds i8, i8* %111, i64 1
%116 = load i8, i8* %115
%117 = icmp eq i8 %116, 0
br i1 %117, label %118, label %109
118: ; preds = %102, %109, %114, %61, %106
%119 = phi i8* [ %99, %106 ], [ %0, %61 ], [ %99, %114 ], [ %99, %109 ], [ %103, %102 ]
%120 = phi i8* [ %99, %106 ], [ %0, %61 ], [ %111, %109 ], [ %115, %114 ], [ %103, %102 ]
%121 = ptrtoint i8* %120 to i64
%122 = ptrtoint i8* %119 to i64
%123 = sub i64 %121, %122
%124 = trunc i64 %123 to i32
%125 = call i32 @memcpy(i8* %3, i8* %119, i32 %124)
%126 = shl i64 %123, 32
%127 = ashr exact i64 %126, 32
%128 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %127
store i8 0, i8* %128
%129 = call i8* @strdup(i8* %3)
br label %130
130: ; preds = %118, %87, %46, %22, %6
%131 = phi i8* [ %7, %6 ], [ %31, %22 ], [ %55, %46 ], [ %96, %87 ], [ %129, %118 ]
ret i8* %131
}