#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 */
int /*<<< orphan*/ polyline(float **, int);
int strlen(char *);
void plot_string(char *str, float startx, float starty, float startz,
                 float base[], float up[], int rjustify) {
  static float zero[] = {0, 0, 0, .8, .4, .8, .4, 0, 0, 0},
               one[] = {0, 0, 0, .8},
               two[] = {.4, 0, 0, 0, 0, .4, .4, .4, .4, .8, 0, .8},
               three[] = {0, 0, .4, 0, .4, .4, 0, .4, .4, .4, .4, .8, 0, .8},
               four[] = {0, .8, 0, .4, .4, .4, .4, .8, .4, 0},
               five[] = {0, 0, .4, 0, .4, .4, 0, .4, 0, .8, .4, .8},
               six[] = {.4, .8, 0, .8, 0, 0, .4, 0, .4, .4, 0, .4},
               seven[] = {0, .7, 0, .8, .4, .8, .4, 0},
               eight[] = {0, 0, 0, .8, .4, .8, .4, 0, 0, 0, 0, .4, .4, .4},
               nine[] = {.4, .4, 0, .4, 0, .8, .4, .8, .4, 0},
               dash[] = {0, .4, .4, .4},
               dot[] = {0, 0, 0, .1, .1, .1, .1, 0, 0, 0},
               west[] = {0., 0.8, 0., 0., 0.2, 0.4, 0.4, 0.0, 0.4, 0.8},
               east[] = {0.4, 0.8, 0.0, 0.8, 0.0, 0.4, 0.3,
                         0.4, 0.0, 0.4, 0.0, 0.0, 0.4, 0.0},
               north[] = {0., 0.0, 0., 0.8, 0.4, 0.0, 0.4, 0.8},
               south[] = {0.0, 0.1, 0.1, 0.0, 0.3, 0.0, 0.4, 0.1, 0.4, 0.3,
                          0.0, 0.5, 0.0, 0.7, 0.1, 0.8, 0.3, 0.8, 0.4, 0.7};
  static float *index[16] = {zero, one,   two,   three, four, five,
                             six,  seven, eight, nine,  dash, dot,
                             west, east,  north, south};
  static float width[16] = {0.6, 0.2, 0.6, 0.6, 0.6, 0.6, 0.6, 0.6,
                            0.6, 0.6, 0.6, 0.3, 0.6, 0.6, 0.6, 0.6};
  static int verts[16] = {5, 2, 6, 7, 5, 6, 6, 4, 7, 5, 2, 5, 5, 7, 4, 10};
  float *temp, plot[100][3];
  float cx, cy, cz;
  int i, j, k, len;
  cx = startx;
  cy = starty;
  cz = startz;
  len = strlen(str);
  if (rjustify) {
    for (i = len - 1; i >= 0; i--) {
      if (str[i] == '-')
        k = 10;
      else if (str[i] == '.')
        k = 11;
      else if (str[i] == 'W')
        k = 12;
      else if (str[i] == 'E')
        k = 13;
      else if (str[i] == 'N')
        k = 14;
      else if (str[i] == 'S')
        k = 15;
      else if (str[i] >= '0' && str[i] <= '9')
        k = str[i] - '0';
      else
        continue;
      cx += width[k] * base[0];
      cy += width[k] * base[1];
      cz += width[k] * base[2];
      temp = index[k];
      for (j = 0; j < verts[k]; j++) {
        float x, y;
        x = *temp++;
        y = *temp++;
        plot[j][0] = cx - x * base[0] + y * up[0];
        plot[j][1] = cy - x * base[1] + y * up[1];
        plot[j][2] = cz - x * base[2] + y * up[2];
      }
      polyline(plot, verts[k]);
    }
  } else {
    for (i = 0; i < len; i++) {
      if (str[i] == '-')
        k = 10;
      else if (str[i] == '.')
        k = 11;
      else if (str[i] == 'W')
        k = 12;
      else if (str[i] == 'N')
        k = 14;
      else if (str[i] == 'S')
        k = 15;
      else if (str[i] == 'E')
        k = 13;
      else if (str[i] >= '0' && str[i] <= '9')
        k = str[i] - '0';
      else
        continue;
      temp = index[k];
      for (j = 0; j < verts[k]; j++) {
        float x, y;
        x = *temp++;
        y = *temp++;
        plot[j][0] = cx + x * base[0] + y * up[0];
        plot[j][1] = cy + x * base[1] + y * up[1];
        plot[j][2] = cz + x * base[2] + y * up[2];
      }
      polyline(plot, verts[k]);
      cx += width[k] * base[0];
      cy += width[k] * base[1];
      cz += width[k] * base[2];
    }
  }
}


x86 assembly (clang, -O0):
<plot_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x520,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %ecx,-0x2c(%rbp)
movss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x4f4(%rbp)
ff
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x4f8(%rbp)
ff
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x4fc(%rbp)
ff
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x50c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1577 <plot_string+0x457>
mov    -0x50c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x500(%rbp)
cmpl   $0x0,-0x500(%rbp)
jl     1572 <plot_string+0x452>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    11cc <plot_string+0xac>
movl   $0xa,-0x508(%rbp)
jmp    12ff <plot_string+0x1df>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    11f3 <plot_string+0xd3>
movl   $0xb,-0x508(%rbp)
jmp    12fa <plot_string+0x1da>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x57,%eax
jne    121a <plot_string+0xfa>
movl   $0xc,-0x508(%rbp)
jmp    12f5 <plot_string+0x1d5>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x45,%eax
jne    1241 <plot_string+0x121>
movl   $0xd,-0x508(%rbp)
jmp    12f0 <plot_string+0x1d0>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1268 <plot_string+0x148>
movl   $0xe,-0x508(%rbp)
jmp    12eb <plot_string+0x1cb>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x53,%eax
jne    128f <plot_string+0x16f>
movl   $0xf,-0x508(%rbp)
jmp    12e6 <plot_string+0x1c6>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     12dc <plot_string+0x1bc>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     12dc <plot_string+0x1bc>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x508(%rbp)
jmp    12e1 <plot_string+0x1c1>
jmp    155e <plot_string+0x43e>
jmp    12e6 <plot_string+0x1c6>
jmp    12eb <plot_string+0x1cb>
jmp    12f0 <plot_string+0x1d0>
jmp    12f5 <plot_string+0x1d5>
jmp    12fa <plot_string+0x1da>
jmp    12ff <plot_string+0x1df>
movslq -0x508(%rbp),%rcx
lea    0x30a3(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x4f4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4f4(%rbp)
ff
movslq -0x508(%rbp),%rcx
lea    0x3070(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x4f8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4f8(%rbp)
ff
movslq -0x508(%rbp),%rcx
lea    0x303c(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x4fc(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4fc(%rbp)
ff
movslq -0x508(%rbp),%rcx
lea    0x2f88(%rip),%rax
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x504(%rbp)
mov    -0x504(%rbp),%eax
movslq -0x508(%rbp),%rdx
lea    0x3022(%rip),%rcx
cmp    (%rcx,%rdx,4),%eax
jge    1541 <plot_string+0x421>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x510(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x514(%rbp)
ff
movss  -0x4f4(%rbp),%xmm0
ff
movss  -0x510(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x514(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x504(%rbp),%rcx
lea    -0x4f0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,(%rax)
movss  -0x4f8(%rbp),%xmm0
ff
movss  -0x510(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x514(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x504(%rbp),%rcx
lea    -0x4f0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x4(%rax)
movss  -0x4fc(%rbp),%xmm0
ff
movss  -0x510(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x514(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x504(%rbp),%rcx
lea    -0x4f0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x8(%rax)
mov    -0x504(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x504(%rbp)
jmp    13ba <plot_string+0x29a>
lea    -0x4f0(%rbp),%rdi
movslq -0x508(%rbp),%rcx
lea    0x2e9a(%rip),%rax
mov    (%rax,%rcx,4),%esi
call   1040 <polyline@plt>
mov    -0x500(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x500(%rbp)
jmp    1198 <plot_string+0x78>
jmp    193e <plot_string+0x81e>
movl   $0x0,-0x500(%rbp)
mov    -0x500(%rbp),%eax
cmp    -0x50c(%rbp),%eax
jge    1939 <plot_string+0x819>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    15ba <plot_string+0x49a>
movl   $0xa,-0x508(%rbp)
jmp    16ed <plot_string+0x5cd>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    15e1 <plot_string+0x4c1>
movl   $0xb,-0x508(%rbp)
jmp    16e8 <plot_string+0x5c8>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x57,%eax
jne    1608 <plot_string+0x4e8>
movl   $0xc,-0x508(%rbp)
jmp    16e3 <plot_string+0x5c3>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    162f <plot_string+0x50f>
movl   $0xe,-0x508(%rbp)
jmp    16de <plot_string+0x5be>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x53,%eax
jne    1656 <plot_string+0x536>
movl   $0xf,-0x508(%rbp)
jmp    16d9 <plot_string+0x5b9>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x45,%eax
jne    167d <plot_string+0x55d>
movl   $0xd,-0x508(%rbp)
jmp    16d4 <plot_string+0x5b4>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     16ca <plot_string+0x5aa>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     16ca <plot_string+0x5aa>
mov    -0x8(%rbp),%rax
movslq -0x500(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x508(%rbp)
jmp    16cf <plot_string+0x5af>
jmp    1925 <plot_string+0x805>
jmp    16d4 <plot_string+0x5b4>
jmp    16d9 <plot_string+0x5b9>
jmp    16de <plot_string+0x5be>
jmp    16e3 <plot_string+0x5c3>
jmp    16e8 <plot_string+0x5c8>
jmp    16ed <plot_string+0x5cd>
movslq -0x508(%rbp),%rcx
lea    0x2c35(%rip),%rax
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x504(%rbp)
mov    -0x504(%rbp),%eax
movslq -0x508(%rbp),%rdx
lea    0x2ccf(%rip),%rcx
cmp    (%rcx,%rdx,4),%eax
jge    186d <plot_string+0x74d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x518(%rbp)
ff
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x51c(%rbp)
ff
movss  -0x4f4(%rbp),%xmm0
ff
movss  -0x518(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x51c(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x504(%rbp),%rcx
lea    -0x4f0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,(%rax)
movss  -0x4f8(%rbp),%xmm0
ff
movss  -0x518(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x51c(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x504(%rbp),%rcx
lea    -0x4f0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x4(%rax)
movss  -0x4fc(%rbp),%xmm0
ff
movss  -0x518(%rbp),%xmm1
ff
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x51c(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x504(%rbp),%rcx
lea    -0x4f0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movss  %xmm0,0x8(%rax)
mov    -0x504(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x504(%rbp)
jmp    170d <plot_string+0x5ed>
lea    -0x4f0(%rbp),%rdi
movslq -0x508(%rbp),%rcx
lea    0x2b6e(%rip),%rax
mov    (%rax,%rcx,4),%esi
call   1040 <polyline@plt>
movslq -0x508(%rbp),%rcx
lea    0x2b18(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x4f4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4f4(%rbp)
ff
movslq -0x508(%rbp),%rcx
lea    0x2ae5(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x4f8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4f8(%rbp)
ff
movslq -0x508(%rbp),%rcx
lea    0x2ab1(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x4fc(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4fc(%rbp)
ff
mov    -0x500(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x500(%rbp)
jmp    1581 <plot_string+0x461>
jmp    193e <plot_string+0x81e>
add    $0x520,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<plot_string>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x568,%rsp
mov    %ecx,%ebp
mov    %rdx,%r14
mov    %rsi,%r15
movaps %xmm2,(%rsp)
movaps %xmm1,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
mov    %rdi,%rbx
call   1030 <strlen@plt>
test   %ebp,%ebp
mov    %rbx,0x38(%rsp)
je     14b4 <plot_string+0x394>
test   %eax,%eax
movaps (%rsp),%xmm0
movaps 0x20(%rsp),%xmm1
jle    1803 <plot_string+0x6e3>
mov    %eax,%r12d
unpcklps 0x10(%rsp),%xmm1
lea    0xb8(%rsp),%rbp
nopl   (%rax)
lea    -0x1(%r12),%r13
mov    %r13d,%eax
movsbq (%rbx,%rax,1),%rax
lea    -0x2d(%rax),%edx
cmp    $0x2a,%dl
ja     11b4 <plot_string+0x94>
mov    $0xa,%ecx
movzbl %dl,%edx
lea    0xe5c(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
mov    $0xb,%ecx
jmp    11f0 <plot_string+0xd0>
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     1346 <plot_string+0x226>
mov    $0xffffffd0,%ecx
add    %rcx,%rax
mov    %rax,%rcx
jmp    11f0 <plot_string+0xd0>
mov    $0xd,%ecx
jmp    11f0 <plot_string+0xd0>
mov    $0xe,%ecx
jmp    11f0 <plot_string+0xd0>
mov    $0xf,%ecx
jmp    11f0 <plot_string+0xd0>
mov    $0xc,%ecx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%eax
lea    0xf67(%rip),%rcx
movss  (%rcx,%rax,4),%xmm5
movsd  (%r15),%xmm10
movaps %xmm5,%xmm7
shufps $0x0,%xmm5,%xmm7
mulps  %xmm10,%xmm7
addps  %xmm1,%xmm7
movss  0x8(%r15),%xmm12
mulss  %xmm12,%xmm5
addss  %xmm0,%xmm5
lea    0xf79(%rip),%rcx
mov    (%rcx,%rax,4),%esi
lea    0x2b6f(%rip),%rcx
mov    (%rcx,%rax,8),%rdx
movss  (%r14),%xmm15
movss  0x4(%r14),%xmm13
cmp    $0x2,%esi
mov    $0x1,%eax
cmovge %esi,%eax
movss  0x8(%r14),%xmm4
movaps %xmm7,%xmm11
shufps $0x55,%xmm7,%xmm11
movaps %xmm10,%xmm6
shufps $0x55,%xmm10,%xmm6
cmp    $0x4,%eax
movaps %xmm5,0x40(%rsp)
movaps %xmm7,(%rsp)
jb     129e <plot_string+0x17e>
lea    (%rdx,%rax,8),%rcx
lea    0xb0(%rsp),%rdi
cmp    %rcx,%rdi
jae    1360 <plot_string+0x240>
lea    (%rax,%rax,2),%rcx
lea    (%rsp,%rcx,4),%rcx
add    $0xb0,%rcx
cmp    %rcx,%rdx
jae    1360 <plot_string+0x240>
xor    %edi,%edi
mov    %rdx,%rcx
lea    (%rdi,%rdi,2),%rdx
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
sub    %rdi,%rax
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rdi,8),%xmm0
movss  0x4(%rcx,%rdi,8),%xmm1
movaps %xmm0,%xmm2
mulss  %xmm10,%xmm2
movaps %xmm7,%xmm3
subss  %xmm2,%xmm3
movaps %xmm1,%xmm2
mulss  %xmm15,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,-0x8(%rdx)
movaps %xmm0,%xmm2
mulss  %xmm6,%xmm2
movaps %xmm11,%xmm3
subss  %xmm2,%xmm3
movaps %xmm1,%xmm2
mulss  %xmm13,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,-0x4(%rdx)
mulss  %xmm12,%xmm0
movaps %xmm5,%xmm2
subss  %xmm0,%xmm2
mulss  %xmm4,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,(%rdx)
add    $0xc,%rdx
add    $0x1,%rdi
cmp    %rdi,%rax
jne    12c0 <plot_string+0x1a0>
lea    0xb0(%rsp),%rdi
call   1040 <polyline@plt>
movaps 0x40(%rsp),%xmm0
movaps (%rsp),%xmm1
cmp    $0x1,%r12
mov    %r13,%r12
jg     1180 <plot_string+0x60>
jmp    1803 <plot_string+0x6e3>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%r8
mov    %eax,%edi
and    $0x7ffffffc,%edi
lea    (%rdx,%rdi,8),%rcx
movaps %xmm10,%xmm0
shufps $0x0,%xmm10,%xmm0
movaps %xmm0,0x10(%rsp)
shufps $0x0,%xmm7,%xmm7
movaps %xmm7,0x90(%rsp)
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
movaps %xmm0,0x80(%rsp)
movaps %xmm13,%xmm0
shufps $0x0,%xmm13,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm12,%xmm0
shufps $0x0,%xmm12,%xmm0
movaps %xmm0,0x60(%rsp)
shufps $0x0,%xmm5,%xmm5
movaps %xmm5,0x50(%rsp)
movaps %xmm4,%xmm14
shufps $0x0,%xmm4,%xmm14
lea    0xb0(%rsp),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdx,%rbp,8),%xmm2
movups 0x10(%rdx,%rbp,8),%xmm7
movaps %xmm2,%xmm8
shufps $0x88,%xmm7,%xmm8
shufps $0xdd,%xmm7,%xmm2
movaps %xmm8,%xmm7
mulps  0x10(%rsp),%xmm7
movaps 0x90(%rsp),%xmm9
subps  %xmm7,%xmm9
movaps %xmm2,%xmm7
mulps  0x80(%rsp),%xmm7
addps  %xmm9,%xmm7
movaps %xmm8,%xmm1
mulps  %xmm6,%xmm1
movaps %xmm11,%xmm5
subps  %xmm1,%xmm5
movaps %xmm2,%xmm1
mulps  0x70(%rsp),%xmm1
addps  %xmm5,%xmm1
mulps  0x60(%rsp),%xmm8
movaps 0x50(%rsp),%xmm5
subps  %xmm8,%xmm5
mulps  %xmm14,%xmm2
addps  %xmm5,%xmm2
movaps %xmm2,%xmm5
shufps $0xd4,%xmm7,%xmm5
movaps %xmm1,%xmm0
movlhps %xmm7,%xmm0
shufps $0x82,%xmm5,%xmm0
movaps %xmm7,%xmm5
unpckhpd %xmm1,%xmm5
movaps %xmm2,%xmm3
shufps $0x11,%xmm1,%xmm3
shufps $0x82,%xmm5,%xmm3
shufps $0xff,%xmm2,%xmm1
shufps $0x23,%xmm2,%xmm7
shufps $0x82,%xmm1,%xmm7
movaps %xmm7,0x20(%rbx)
movaps %xmm3,0x10(%rbx)
movaps %xmm0,(%rbx)
add    $0x4,%rbp
add    $0x30,%rbx
cmp    %rbp,%rdi
jne    13e0 <plot_string+0x2c0>
cmp    %rax,%rdi
mov    0x38(%rsp),%rbx
mov    %r8,%rbp
movaps 0x40(%rsp),%xmm5
movaps (%rsp),%xmm7
jne    12a3 <plot_string+0x183>
jmp    1330 <plot_string+0x210>
test   %eax,%eax
movaps (%rsp),%xmm8
movaps 0x20(%rsp),%xmm7
jle    1803 <plot_string+0x6e3>
mov    %eax,%eax
mov    %rax,0xa8(%rsp)
unpcklps 0x10(%rsp),%xmm7
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
movsbq (%rbx,%r13,1),%rax
lea    -0x2d(%rax),%edx
cmp    $0x2a,%dl
ja     150c <plot_string+0x3ec>
mov    $0xa,%ecx
movzbl %dl,%edx
lea    0xbb0(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
mov    $0xb,%ecx
jmp    1540 <plot_string+0x420>
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     1698 <plot_string+0x578>
mov    $0xffffffd0,%ecx
add    %rcx,%rax
mov    %rax,%rcx
jmp    1540 <plot_string+0x420>
mov    $0xd,%ecx
jmp    1540 <plot_string+0x420>
mov    $0xe,%ecx
jmp    1540 <plot_string+0x420>
mov    $0xf,%ecx
jmp    1540 <plot_string+0x420>
mov    $0xc,%ecx
nop
mov    %ecx,%r12d
lea    0xc56(%rip),%rax
mov    (%rax,%r12,4),%esi
lea    0x284b(%rip),%rax
mov    (%rax,%r12,8),%rdx
movss  (%r15),%xmm11
movss  0x4(%r15),%xmm12
movss  (%r14),%xmm13
movss  0x4(%r14),%xmm14
movss  0x8(%r15),%xmm4
movss  0x8(%r14),%xmm5
cmp    $0x2,%esi
mov    $0x1,%eax
cmovge %esi,%eax
movaps %xmm7,%xmm6
shufps $0x55,%xmm7,%xmm6
cmp    $0x4,%eax
movaps %xmm8,(%rsp)
movaps %xmm7,0x20(%rsp)
jb     15c9 <plot_string+0x4a9>
lea    (%rdx,%rax,8),%rcx
lea    0xb0(%rsp),%rdi
cmp    %rcx,%rdi
jae    16b0 <plot_string+0x590>
lea    (%rax,%rax,2),%rcx
lea    (%rsp,%rcx,4),%rcx
add    $0xb0,%rcx
cmp    %rcx,%rdx
jae    16b0 <plot_string+0x590>
xor    %edi,%edi
mov    %rdx,%rcx
lea    (%rdi,%rdi,2),%rdx
lea    0xb8(%rsp),%rbp
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
sub    %rdi,%rax
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rdi,8),%xmm0
movss  0x4(%rcx,%rdi,8),%xmm1
movaps %xmm0,%xmm2
mulss  %xmm11,%xmm2
addss  %xmm7,%xmm2
movaps %xmm1,%xmm3
mulss  %xmm13,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,-0x8(%rdx)
movaps %xmm0,%xmm2
mulss  %xmm12,%xmm2
addss  %xmm6,%xmm2
movaps %xmm1,%xmm3
mulss  %xmm14,%xmm3
addss  %xmm2,%xmm3
movss  %xmm3,-0x4(%rdx)
mulss  %xmm4,%xmm0
addss  %xmm8,%xmm0
mulss  %xmm5,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rdx)
add    $0xc,%rdx
add    $0x1,%rdi
cmp    %rdi,%rax
jne    15f0 <plot_string+0x4d0>
lea    0xb0(%rsp),%rdi
call   1040 <polyline@plt>
movaps 0x20(%rsp),%xmm7
movaps (%rsp),%xmm8
lea    0xaeb(%rip),%rax
movss  (%rax,%r12,4),%xmm0
movsd  (%r15),%xmm1
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm2,%xmm7
mulss  0x8(%r15),%xmm0
addss  %xmm0,%xmm8
add    $0x1,%r13
cmp    0xa8(%rsp),%r13
jne    14e0 <plot_string+0x3c0>
jmp    1803 <plot_string+0x6e3>
nop
mov    %eax,%edi
and    $0x7ffffffc,%edi
lea    (%rdx,%rdi,8),%rcx
movaps %xmm11,%xmm0
shufps $0x0,%xmm11,%xmm0
movaps %xmm0,0x10(%rsp)
shufps $0x0,%xmm7,%xmm7
movaps %xmm7,0x90(%rsp)
movaps %xmm13,%xmm0
shufps $0x0,%xmm13,%xmm0
movaps %xmm0,0x80(%rsp)
movaps %xmm12,%xmm0
shufps $0x0,%xmm12,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm14,%xmm0
shufps $0x0,%xmm14,%xmm0
movaps %xmm0,0x60(%rsp)
movaps %xmm4,%xmm0
shufps $0x0,%xmm4,%xmm0
movaps %xmm0,0x50(%rsp)
shufps $0x0,%xmm8,%xmm8
movaps %xmm8,0x40(%rsp)
movaps %xmm5,%xmm15
shufps $0x0,%xmm5,%xmm15
lea    0xb0(%rsp),%rbx
xor    %ebp,%ebp
nopl   (%rax)
movups (%rdx,%rbp,8),%xmm8
movups 0x10(%rdx,%rbp,8),%xmm7
movaps %xmm8,%xmm9
shufps $0x88,%xmm7,%xmm9
shufps $0xdd,%xmm7,%xmm8
movaps %xmm9,%xmm10
mulps  0x10(%rsp),%xmm10
addps  0x90(%rsp),%xmm10
movaps %xmm8,%xmm7
mulps  0x80(%rsp),%xmm7
addps  %xmm10,%xmm7
movaps %xmm9,%xmm0
mulps  0x70(%rsp),%xmm0
addps  %xmm6,%xmm0
movaps %xmm8,%xmm1
mulps  0x60(%rsp),%xmm1
addps  %xmm0,%xmm1
mulps  0x50(%rsp),%xmm9
addps  0x40(%rsp),%xmm9
mulps  %xmm15,%xmm8
addps  %xmm9,%xmm8
movaps %xmm8,%xmm0
shufps $0xd4,%xmm7,%xmm0
movaps %xmm1,%xmm2
movlhps %xmm7,%xmm2
shufps $0x82,%xmm0,%xmm2
movaps %xmm7,%xmm0
unpckhpd %xmm1,%xmm0
movaps %xmm8,%xmm3
shufps $0x11,%xmm1,%xmm3
shufps $0x82,%xmm0,%xmm3
shufps $0xff,%xmm8,%xmm1
shufps $0x23,%xmm8,%xmm7
shufps $0x82,%xmm1,%xmm7
movaps %xmm7,0x20(%rbx)
movaps %xmm3,0x10(%rbx)
movaps %xmm2,(%rbx)
add    $0x4,%rbp
add    $0x30,%rbx
cmp    %rbp,%rdi
jne    1730 <plot_string+0x610>
cmp    %rax,%rdi
mov    0x38(%rsp),%rbx
movaps (%rsp),%xmm8
movaps 0x20(%rsp),%xmm7
jne    15ce <plot_string+0x4ae>
jmp    1657 <plot_string+0x537>
add    $0x568,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@plot_string.zero = internal global [10 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00]
@plot_string.one = internal global [4 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000]
@plot_string.two = internal global [12 x float] [float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000]
@plot_string.three = internal global [14 x float] [float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000]
@plot_string.four = internal global [10 x float] [float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.five = internal global [12 x float] [float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000]
@plot_string.six = internal global [12 x float] [float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000]
@plot_string.seven = internal global [8 x float] [float 0.000000e+00, float 0x3FE6666660000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.eight = internal global [14 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000]
@plot_string.nine = internal global [10 x float] [float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.dash = internal global [4 x float] [float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000]
@plot_string.dot = internal global [10 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00]
@plot_string.west = internal global [10 x float] [float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0x3FC99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FE99999A0000000]
@plot_string.east = internal global [14 x float] [float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD3333340000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.north = internal global [8 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FE99999A0000000]
@plot_string.south = internal global [20 x float] [float 0.000000e+00, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0.000000e+00, float 0x3FD3333340000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FB99999A0000000, float 0x3FD99999A0000000, float 0x3FD3333340000000, float 0.000000e+00, float 5.000000e-01, float 0.000000e+00, float 0x3FE6666660000000, float 0x3FB99999A0000000, float 0x3FE99999A0000000, float 0x3FD3333340000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE6666660000000]
@plot_string.index = internal global [16 x float*] [float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.zero, i32 0, i32 0), float* getelementptr inbounds ([4 x float], [4 x float]* @plot_string.one, i32 0, i32 0), float* getelementptr inbounds ([12 x float], [12 x float]* @plot_string.two, i32 0, i32 0), float* getelementptr inbounds ([14 x float], [14 x float]* @plot_string.three, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.four, i32 0, i32 0), float* getelementptr inbounds ([12 x float], [12 x float]* @plot_string.five, i32 0, i32 0), float* getelementptr inbounds ([12 x float], [12 x float]* @plot_string.six, i32 0, i32 0), float* getelementptr inbounds ([8 x float], [8 x float]* @plot_string.seven, i32 0, i32 0), float* getelementptr inbounds ([14 x float], [14 x float]* @plot_string.eight, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.nine, i32 0, i32 0), float* getelementptr inbounds ([4 x float], [4 x float]* @plot_string.dash, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.dot, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.west, i32 0, i32 0), float* getelementptr inbounds ([14 x float], [14 x float]* @plot_string.east, i32 0, i32 0), float* getelementptr inbounds ([8 x float], [8 x float]* @plot_string.north, i32 0, i32 0), float* getelementptr inbounds ([20 x float], [20 x float]* @plot_string.south, i32 0, i32 0)]
@plot_string.width = internal global [16 x float] [float 0x3FE3333340000000, float 0x3FC99999A0000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FD3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000]
@plot_string.verts = internal global [16 x i32] [i32 5, i32 2, i32 6, i32 7, i32 5, i32 6, i32 6, i32 4, i32 7, i32 5, i32 2, i32 5, i32 5, i32 7, i32 4, i32 10]
define void @plot_string(i8* %0, float %1, float %2, float %3, float* %4, float* %5, i32 %6) {
%8 = alloca i8*
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float*
%13 = alloca float*
%14 = alloca i32
%15 = alloca float*
%16 = alloca [100 x [3 x float]]
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
store i8* %0, i8** %8
store float %1, float* %9
store float %2, float* %10
store float %3, float* %11
store float* %4, float** %12
store float* %5, float** %13
store i32 %6, i32* %14
%28 = load float, float* %9
store float %28, float* %17
%29 = load float, float* %10
store float %29, float* %18
%30 = load float, float* %11
store float %30, float* %19
%31 = load i8*, i8** %8
%32 = call i32 @strlen(i8* %31)
store i32 %32, i32* %23
%33 = load i32, i32* %14
%34 = icmp ne i32 %33, 0
br i1 %34, label %35, label %235
35: ; preds = %7
%36 = load i32, i32* %23
%37 = sub nsw i32 %36, 1
store i32 %37, i32* %20
br label %38
38: ; preds = %231, %35
%39 = load i32, i32* %20
%40 = icmp sge i32 %39, 0
br i1 %40, label %41, label %234
41: ; preds = %38
%42 = load i8*, i8** %8
%43 = load i32, i32* %20
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = icmp eq i32 %47, 45
br i1 %48, label %49, label %50
49: ; preds = %41
store i32 10, i32* %22
br label %126
50: ; preds = %41
%51 = load i8*, i8** %8
%52 = load i32, i32* %20
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %51, i64 %53
%55 = load i8, i8* %54
%56 = sext i8 %55 to i32
%57 = icmp eq i32 %56, 46
br i1 %57, label %58, label %59
58: ; preds = %50
store i32 11, i32* %22
br label %125
59: ; preds = %50
%60 = load i8*, i8** %8
%61 = load i32, i32* %20
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %60, i64 %62
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = icmp eq i32 %65, 87
br i1 %66, label %67, label %68
67: ; preds = %59
store i32 12, i32* %22
br label %124
68: ; preds = %59
%69 = load i8*, i8** %8
%70 = load i32, i32* %20
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp eq i32 %74, 69
br i1 %75, label %76, label %77
76: ; preds = %68
store i32 13, i32* %22
br label %123
77: ; preds = %68
%78 = load i8*, i8** %8
%79 = load i32, i32* %20
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %78, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = icmp eq i32 %83, 78
br i1 %84, label %85, label %86
85: ; preds = %77
store i32 14, i32* %22
br label %122
86: ; preds = %77
%87 = load i8*, i8** %8
%88 = load i32, i32* %20
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i8, i8* %87, i64 %89
%91 = load i8, i8* %90
%92 = sext i8 %91 to i32
%93 = icmp eq i32 %92, 83
br i1 %93, label %94, label %95
94: ; preds = %86
store i32 15, i32* %22
br label %121
95: ; preds = %86
%96 = load i8*, i8** %8
%97 = load i32, i32* %20
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %96, i64 %98
%100 = load i8, i8* %99
%101 = sext i8 %100 to i32
%102 = icmp sge i32 %101, 48
br i1 %102, label %103, label %119
103: ; preds = %95
%104 = load i8*, i8** %8
%105 = load i32, i32* %20
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = icmp sle i32 %109, 57
br i1 %110, label %111, label %119
111: ; preds = %103
%112 = load i8*, i8** %8
%113 = load i32, i32* %20
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %112, i64 %114
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = sub nsw i32 %117, 48
store i32 %118, i32* %22
br label %120
119: ; preds = %103, %95
br label %231
120: ; preds = %111
br label %121
121: ; preds = %120, %94
br label %122
122: ; preds = %121, %85
br label %123
123: ; preds = %122, %76
br label %124
124: ; preds = %123, %67
br label %125
125: ; preds = %124, %58
br label %126
126: ; preds = %125, %49
%127 = load i32, i32* %22
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %128
%130 = load float, float* %129
%131 = load float*, float** %12
%132 = getelementptr inbounds float, float* %131, i64 0
%133 = load float, float* %132
%134 = load float, float* %17
%135 = call float @llvm.fmuladd.f32(float %130, float %133, float %134)
store float %135, float* %17
%136 = load i32, i32* %22
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %137
%139 = load float, float* %138
%140 = load float*, float** %12
%141 = getelementptr inbounds float, float* %140, i64 1
%142 = load float, float* %141
%143 = load float, float* %18
%144 = call float @llvm.fmuladd.f32(float %139, float %142, float %143)
store float %144, float* %18
%145 = load i32, i32* %22
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %146
%148 = load float, float* %147
%149 = load float*, float** %12
%150 = getelementptr inbounds float, float* %149, i64 2
%151 = load float, float* %150
%152 = load float, float* %19
%153 = call float @llvm.fmuladd.f32(float %148, float %151, float %152)
store float %153, float* %19
%154 = load i32, i32* %22
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [16 x float*], [16 x float*]* @plot_string.index, i64 0, i64 %155
%157 = load float*, float** %156
store float* %157, float** %15
store i32 0, i32* %21
br label %158
158: ; preds = %220, %126
%159 = load i32, i32* %21
%160 = load i32, i32* %22
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [16 x i32], [16 x i32]* @plot_string.verts, i64 0, i64 %161
%163 = load i32, i32* %162
%164 = icmp slt i32 %159, %163
br i1 %164, label %165, label %223
165: ; preds = %158
%166 = load float*, float** %15
%167 = getelementptr inbounds float, float* %166, i32 1
store float* %167, float** %15
%168 = load float, float* %166
store float %168, float* %24
%169 = load float*, float** %15
%170 = getelementptr inbounds float, float* %169, i32 1
store float* %170, float** %15
%171 = load float, float* %169
store float %171, float* %25
%172 = load float, float* %17
%173 = load float, float* %24
%174 = load float*, float** %12
%175 = getelementptr inbounds float, float* %174, i64 0
%176 = load float, float* %175
%177 = fneg float %173
%178 = call float @llvm.fmuladd.f32(float %177, float %176, float %172)
%179 = load float, float* %25
%180 = load float*, float** %13
%181 = getelementptr inbounds float, float* %180, i64 0
%182 = load float, float* %181
%183 = call float @llvm.fmuladd.f32(float %179, float %182, float %178)
%184 = load i32, i32* %21
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 %185
%187 = getelementptr inbounds [3 x float], [3 x float]* %186, i64 0, i64 0
store float %183, float* %187
%188 = load float, float* %18
%189 = load float, float* %24
%190 = load float*, float** %12
%191 = getelementptr inbounds float, float* %190, i64 1
%192 = load float, float* %191
%193 = fneg float %189
%194 = call float @llvm.fmuladd.f32(float %193, float %192, float %188)
%195 = load float, float* %25
%196 = load float*, float** %13
%197 = getelementptr inbounds float, float* %196, i64 1
%198 = load float, float* %197
%199 = call float @llvm.fmuladd.f32(float %195, float %198, float %194)
%200 = load i32, i32* %21
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 %201
%203 = getelementptr inbounds [3 x float], [3 x float]* %202, i64 0, i64 1
store float %199, float* %203
%204 = load float, float* %19
%205 = load float, float* %24
%206 = load float*, float** %12
%207 = getelementptr inbounds float, float* %206, i64 2
%208 = load float, float* %207
%209 = fneg float %205
%210 = call float @llvm.fmuladd.f32(float %209, float %208, float %204)
%211 = load float, float* %25
%212 = load float*, float** %13
%213 = getelementptr inbounds float, float* %212, i64 2
%214 = load float, float* %213
%215 = call float @llvm.fmuladd.f32(float %211, float %214, float %210)
%216 = load i32, i32* %21
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 %217
%219 = getelementptr inbounds [3 x float], [3 x float]* %218, i64 0, i64 2
store float %215, float* %219
br label %220
220: ; preds = %165
%221 = load i32, i32* %21
%222 = add nsw i32 %221, 1
store i32 %222, i32* %21
br label %158
223: ; preds = %158
%224 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 0
%225 = bitcast [3 x float]* %224 to float**
%226 = load i32, i32* %22
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [16 x i32], [16 x i32]* @plot_string.verts, i64 0, i64 %227
%229 = load i32, i32* %228
%230 = call i32 @polyline(float** %225, i32 %229)
br label %231
231: ; preds = %223, %119
%232 = load i32, i32* %20
%233 = add nsw i32 %232, -1
store i32 %233, i32* %20
br label %38
234: ; preds = %38
br label %431
235: ; preds = %7
store i32 0, i32* %20
br label %236
236: ; preds = %427, %235
%237 = load i32, i32* %20
%238 = load i32, i32* %23
%239 = icmp slt i32 %237, %238
br i1 %239, label %240, label %430
240: ; preds = %236
%241 = load i8*, i8** %8
%242 = load i32, i32* %20
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i8, i8* %241, i64 %243
%245 = load i8, i8* %244
%246 = sext i8 %245 to i32
%247 = icmp eq i32 %246, 45
br i1 %247, label %248, label %249
248: ; preds = %240
store i32 10, i32* %22
br label %325
249: ; preds = %240
%250 = load i8*, i8** %8
%251 = load i32, i32* %20
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8, i8* %250, i64 %252
%254 = load i8, i8* %253
%255 = sext i8 %254 to i32
%256 = icmp eq i32 %255, 46
br i1 %256, label %257, label %258
257: ; preds = %249
store i32 11, i32* %22
br label %324
258: ; preds = %249
%259 = load i8*, i8** %8
%260 = load i32, i32* %20
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i8, i8* %259, i64 %261
%263 = load i8, i8* %262
%264 = sext i8 %263 to i32
%265 = icmp eq i32 %264, 87
br i1 %265, label %266, label %267
266: ; preds = %258
store i32 12, i32* %22
br label %323
267: ; preds = %258
%268 = load i8*, i8** %8
%269 = load i32, i32* %20
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i8, i8* %268, i64 %270
%272 = load i8, i8* %271
%273 = sext i8 %272 to i32
%274 = icmp eq i32 %273, 78
br i1 %274, label %275, label %276
275: ; preds = %267
store i32 14, i32* %22
br label %322
276: ; preds = %267
%277 = load i8*, i8** %8
%278 = load i32, i32* %20
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i8, i8* %277, i64 %279
%281 = load i8, i8* %280
%282 = sext i8 %281 to i32
%283 = icmp eq i32 %282, 83
br i1 %283, label %284, label %285
284: ; preds = %276
store i32 15, i32* %22
br label %321
285: ; preds = %276
%286 = load i8*, i8** %8
%287 = load i32, i32* %20
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i8, i8* %286, i64 %288
%290 = load i8, i8* %289
%291 = sext i8 %290 to i32
%292 = icmp eq i32 %291, 69
br i1 %292, label %293, label %294
293: ; preds = %285
store i32 13, i32* %22
br label %320
294: ; preds = %285
%295 = load i8*, i8** %8
%296 = load i32, i32* %20
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i8, i8* %295, i64 %297
%299 = load i8, i8* %298
%300 = sext i8 %299 to i32
%301 = icmp sge i32 %300, 48
br i1 %301, label %302, label %318
302: ; preds = %294
%303 = load i8*, i8** %8
%304 = load i32, i32* %20
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds i8, i8* %303, i64 %305
%307 = load i8, i8* %306
%308 = sext i8 %307 to i32
%309 = icmp sle i32 %308, 57
br i1 %309, label %310, label %318
310: ; preds = %302
%311 = load i8*, i8** %8
%312 = load i32, i32* %20
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i8, i8* %311, i64 %313
%315 = load i8, i8* %314
%316 = sext i8 %315 to i32
%317 = sub nsw i32 %316, 48
store i32 %317, i32* %22
br label %319
318: ; preds = %302, %294
br label %427
319: ; preds = %310
br label %320
320: ; preds = %319, %293
br label %321
321: ; preds = %320, %284
br label %322
322: ; preds = %321, %275
br label %323
323: ; preds = %322, %266
br label %324
324: ; preds = %323, %257
br label %325
325: ; preds = %324, %248
%326 = load i32, i32* %22
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds [16 x float*], [16 x float*]* @plot_string.index, i64 0, i64 %327
%329 = load float*, float** %328
store float* %329, float** %15
store i32 0, i32* %21
br label %330
330: ; preds = %389, %325
%331 = load i32, i32* %21
%332 = load i32, i32* %22
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [16 x i32], [16 x i32]* @plot_string.verts, i64 0, i64 %333
%335 = load i32, i32* %334
%336 = icmp slt i32 %331, %335
br i1 %336, label %337, label %392
337: ; preds = %330
%338 = load float*, float** %15
%339 = getelementptr inbounds float, float* %338, i32 1
store float* %339, float** %15
%340 = load float, float* %338
store float %340, float* %26
%341 = load float*, float** %15
%342 = getelementptr inbounds float, float* %341, i32 1
store float* %342, float** %15
%343 = load float, float* %341
store float %343, float* %27
%344 = load float, float* %17
%345 = load float, float* %26
%346 = load float*, float** %12
%347 = getelementptr inbounds float, float* %346, i64 0
%348 = load float, float* %347
%349 = call float @llvm.fmuladd.f32(float %345, float %348, float %344)
%350 = load float, float* %27
%351 = load float*, float** %13
%352 = getelementptr inbounds float, float* %351, i64 0
%353 = load float, float* %352
%354 = call float @llvm.fmuladd.f32(float %350, float %353, float %349)
%355 = load i32, i32* %21
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 %356
%358 = getelementptr inbounds [3 x float], [3 x float]* %357, i64 0, i64 0
store float %354, float* %358
%359 = load float, float* %18
%360 = load float, float* %26
%361 = load float*, float** %12
%362 = getelementptr inbounds float, float* %361, i64 1
%363 = load float, float* %362
%364 = call float @llvm.fmuladd.f32(float %360, float %363, float %359)
%365 = load float, float* %27
%366 = load float*, float** %13
%367 = getelementptr inbounds float, float* %366, i64 1
%368 = load float, float* %367
%369 = call float @llvm.fmuladd.f32(float %365, float %368, float %364)
%370 = load i32, i32* %21
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 %371
%373 = getelementptr inbounds [3 x float], [3 x float]* %372, i64 0, i64 1
store float %369, float* %373
%374 = load float, float* %19
%375 = load float, float* %26
%376 = load float*, float** %12
%377 = getelementptr inbounds float, float* %376, i64 2
%378 = load float, float* %377
%379 = call float @llvm.fmuladd.f32(float %375, float %378, float %374)
%380 = load float, float* %27
%381 = load float*, float** %13
%382 = getelementptr inbounds float, float* %381, i64 2
%383 = load float, float* %382
%384 = call float @llvm.fmuladd.f32(float %380, float %383, float %379)
%385 = load i32, i32* %21
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 %386
%388 = getelementptr inbounds [3 x float], [3 x float]* %387, i64 0, i64 2
store float %384, float* %388
br label %389
389: ; preds = %337
%390 = load i32, i32* %21
%391 = add nsw i32 %390, 1
store i32 %391, i32* %21
br label %330
392: ; preds = %330
%393 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %16, i64 0, i64 0
%394 = bitcast [3 x float]* %393 to float**
%395 = load i32, i32* %22
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [16 x i32], [16 x i32]* @plot_string.verts, i64 0, i64 %396
%398 = load i32, i32* %397
%399 = call i32 @polyline(float** %394, i32 %398)
%400 = load i32, i32* %22
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %401
%403 = load float, float* %402
%404 = load float*, float** %12
%405 = getelementptr inbounds float, float* %404, i64 0
%406 = load float, float* %405
%407 = load float, float* %17
%408 = call float @llvm.fmuladd.f32(float %403, float %406, float %407)
store float %408, float* %17
%409 = load i32, i32* %22
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %410
%412 = load float, float* %411
%413 = load float*, float** %12
%414 = getelementptr inbounds float, float* %413, i64 1
%415 = load float, float* %414
%416 = load float, float* %18
%417 = call float @llvm.fmuladd.f32(float %412, float %415, float %416)
store float %417, float* %18
%418 = load i32, i32* %22
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %419
%421 = load float, float* %420
%422 = load float*, float** %12
%423 = getelementptr inbounds float, float* %422, i64 2
%424 = load float, float* %423
%425 = load float, float* %19
%426 = call float @llvm.fmuladd.f32(float %421, float %424, float %425)
store float %426, float* %19
br label %427
427: ; preds = %392, %318
%428 = load i32, i32* %20
%429 = add nsw i32 %428, 1
store i32 %429, i32* %20
br label %236
430: ; preds = %236
br label %431
431: ; preds = %430, %234
ret void
}

LLVM IR (-O2):
@plot_string.zero = internal global [10 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00]
@plot_string.one = internal global [4 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000]
@plot_string.two = internal global [12 x float] [float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000]
@plot_string.three = internal global [14 x float] [float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000]
@plot_string.four = internal global [10 x float] [float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.five = internal global [12 x float] [float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000]
@plot_string.six = internal global [12 x float] [float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000]
@plot_string.seven = internal global [8 x float] [float 0.000000e+00, float 0x3FE6666660000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.eight = internal global [14 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000]
@plot_string.nine = internal global [10 x float] [float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.dash = internal global [4 x float] [float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000]
@plot_string.dot = internal global [10 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00]
@plot_string.west = internal global [10 x float] [float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0x3FC99999A0000000, float 0x3FD99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FE99999A0000000]
@plot_string.east = internal global [14 x float] [float 0x3FD99999A0000000, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FE99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FD3333340000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00, float 0.000000e+00, float 0x3FD99999A0000000, float 0.000000e+00]
@plot_string.north = internal global [8 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FE99999A0000000]
@plot_string.south = internal global [20 x float] [float 0.000000e+00, float 0x3FB99999A0000000, float 0x3FB99999A0000000, float 0.000000e+00, float 0x3FD3333340000000, float 0.000000e+00, float 0x3FD99999A0000000, float 0x3FB99999A0000000, float 0x3FD99999A0000000, float 0x3FD3333340000000, float 0.000000e+00, float 5.000000e-01, float 0.000000e+00, float 0x3FE6666660000000, float 0x3FB99999A0000000, float 0x3FE99999A0000000, float 0x3FD3333340000000, float 0x3FE99999A0000000, float 0x3FD99999A0000000, float 0x3FE6666660000000]
@plot_string.index = internal unnamed_addr constant [16 x float*] [float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.zero, i32 0, i32 0), float* getelementptr inbounds ([4 x float], [4 x float]* @plot_string.one, i32 0, i32 0), float* getelementptr inbounds ([12 x float], [12 x float]* @plot_string.two, i32 0, i32 0), float* getelementptr inbounds ([14 x float], [14 x float]* @plot_string.three, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.four, i32 0, i32 0), float* getelementptr inbounds ([12 x float], [12 x float]* @plot_string.five, i32 0, i32 0), float* getelementptr inbounds ([12 x float], [12 x float]* @plot_string.six, i32 0, i32 0), float* getelementptr inbounds ([8 x float], [8 x float]* @plot_string.seven, i32 0, i32 0), float* getelementptr inbounds ([14 x float], [14 x float]* @plot_string.eight, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.nine, i32 0, i32 0), float* getelementptr inbounds ([4 x float], [4 x float]* @plot_string.dash, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.dot, i32 0, i32 0), float* getelementptr inbounds ([10 x float], [10 x float]* @plot_string.west, i32 0, i32 0), float* getelementptr inbounds ([14 x float], [14 x float]* @plot_string.east, i32 0, i32 0), float* getelementptr inbounds ([8 x float], [8 x float]* @plot_string.north, i32 0, i32 0), float* getelementptr inbounds ([20 x float], [20 x float]* @plot_string.south, i32 0, i32 0)]
@plot_string.width = internal unnamed_addr constant [16 x float] [float 0x3FE3333340000000, float 0x3FC99999A0000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FD3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000, float 0x3FE3333340000000]
@plot_string.verts = internal unnamed_addr constant [16 x i32] [i32 5, i32 2, i32 6, i32 7, i32 5, i32 6, i32 6, i32 4, i32 7, i32 5, i32 2, i32 5, i32 5, i32 7, i32 4, i32 10]
define void @plot_string(i8* %0, float %1, float %2, float %3, float* nocapture %4, float* nocapture %5, i32 %6) {
%8 = alloca [100 x [3 x float]]
%9 = bitcast [100 x [3 x float]]* %8 to i8*
%10 = tail call i32 @strlen(i8* %0)
%11 = icmp eq i32 %6, 0
%12 = icmp sgt i32 %10, 0
br i1 %11, label %23, label %13
13: ; preds = %7
br i1 %12, label %14, label %278
14: ; preds = %13
%15 = getelementptr inbounds float, float* %4, i64 2
%16 = getelementptr inbounds float, float* %5, i64 1
%17 = getelementptr inbounds float, float* %5, i64 2
%18 = bitcast [100 x [3 x float]]* %8 to float**
%19 = zext i32 %10 to i64
%20 = insertelement <2 x float> poison, float %1, i64 0
%21 = insertelement <2 x float> %20, float %2, i64 1
%22 = bitcast float* %4 to <2 x float>*
br label %34
23: ; preds = %7
br i1 %12, label %24, label %278
24: ; preds = %23
%25 = getelementptr inbounds float, float* %4, i64 1
%26 = getelementptr inbounds float, float* %5, i64 1
%27 = getelementptr inbounds float, float* %4, i64 2
%28 = getelementptr inbounds float, float* %5, i64 2
%29 = bitcast [100 x [3 x float]]* %8 to float**
%30 = zext i32 %10 to i64
%31 = insertelement <2 x float> poison, float %1, i64 0
%32 = insertelement <2 x float> %31, float %2, i64 1
%33 = bitcast float* %4 to <2 x float>*
br label %156
34: ; preds = %14, %152
%35 = phi i64 [ %19, %14 ], [ %38, %152 ]
%36 = phi float [ %3, %14 ], [ %153, %152 ]
%37 = phi <2 x float> [ %21, %14 ], [ %154, %152 ]
%38 = add nsw i64 %35, -1
%39 = and i64 %38, 4294967295
%40 = getelementptr inbounds i8, i8* %0, i64 %39
%41 = load i8, i8* %40
%42 = sext i8 %41 to i64
switch i8 %41, label %48 [
i8 45, label %53
i8 46, label %43
i8 87, label %44
i8 69, label %45
i8 78, label %46
i8 83, label %47
]
43: ; preds = %34
br label %53
44: ; preds = %34
br label %53
45: ; preds = %34
br label %53
46: ; preds = %34
br label %53
47: ; preds = %34
br label %53
48: ; preds = %34
%49 = add i8 %41, -48
%50 = icmp ult i8 %49, 10
br i1 %50, label %51, label %152
51: ; preds = %48
%52 = add nsw i64 %42, 4294967248
br label %53
53: ; preds = %44, %46, %51, %47, %45, %43, %34
%54 = phi i64 [ 11, %43 ], [ 12, %44 ], [ 13, %45 ], [ 14, %46 ], [ 15, %47 ], [ %52, %51 ], [ 10, %34 ]
%55 = and i64 %54, 4294967295
%56 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %55
%57 = load float, float* %56
%58 = load <2 x float>, <2 x float>* %22
%59 = insertelement <2 x float> poison, float %57, i64 0
%60 = shufflevector <2 x float> %59, <2 x float> poison, <2 x i32> zeroinitializer
%61 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %60, <2 x float> %58, <2 x float> %37)
%62 = load float, float* %15
%63 = call float @llvm.fmuladd.f32(float %57, float %62, float %36)
%64 = getelementptr inbounds [16 x i32], [16 x i32]* @plot_string.verts, i64 0, i64 %55
%65 = load i32, i32* %64
%66 = getelementptr inbounds [16 x float*], [16 x float*]* @plot_string.index, i64 0, i64 %55
%67 = load float*, float** %66
%68 = load float, float* %5
%69 = load float, float* %16
%70 = load float, float* %17
%71 = call i32 @llvm.smax.i32(i32 %65, i32 1)
%72 = zext i32 %71 to i64
%73 = icmp ult i32 %71, 4
br i1 %73, label %124, label %74
74: ; preds = %53
%75 = getelementptr [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %72, i64 0
%76 = shl nuw nsw i64 %72, 1
%77 = getelementptr float, float* %67, i64 %76
%78 = bitcast float* %77 to [100 x [3 x float]]*
%79 = icmp ult [100 x [3 x float]]* %8, %78
%80 = icmp ult float* %67, %75
%81 = and i1 %79, %80
br i1 %81, label %124, label %82
82: ; preds = %74
%83 = and i64 %72, 2147483644
%84 = shl nuw nsw i64 %83, 1
%85 = getelementptr float, float* %67, i64 %84
%86 = shufflevector <2 x float> %58, <2 x float> undef, <4 x i32> zeroinitializer
%87 = shufflevector <2 x float> %61, <2 x float> undef, <4 x i32> zeroinitializer
%88 = insertelement <4 x float> poison, float %68, i64 0
%89 = shufflevector <4 x float> %88, <4 x float> poison, <4 x i32> zeroinitializer
%90 = shufflevector <2 x float> %58, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
%91 = shufflevector <2 x float> %61, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
%92 = insertelement <4 x float> poison, float %69, i64 0
%93 = shufflevector <4 x float> %92, <4 x float> poison, <4 x i32> zeroinitializer
%94 = insertelement <4 x float> poison, float %62, i64 0
%95 = shufflevector <4 x float> %94, <4 x float> poison, <4 x i32> zeroinitializer
%96 = insertelement <4 x float> poison, float %63, i64 0
%97 = shufflevector <4 x float> %96, <4 x float> poison, <4 x i32> zeroinitializer
%98 = insertelement <4 x float> poison, float %70, i64 0
%99 = shufflevector <4 x float> %98, <4 x float> poison, <4 x i32> zeroinitializer
br label %100
100: ; preds = %100, %82
%101 = phi i64 [ 0, %82 ], [ %120, %100 ]
%102 = shl i64 %101, 1
%103 = getelementptr float, float* %67, i64 %102
%104 = bitcast float* %103 to <8 x float>*
%105 = load <8 x float>, <8 x float>* %104
%106 = shufflevector <8 x float> %105, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%107 = shufflevector <8 x float> %105, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%108 = fneg <4 x float> %106
%109 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %108, <4 x float> %86, <4 x float> %87)
%110 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %89, <4 x float> %109)
%111 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %108, <4 x float> %90, <4 x float> %91)
%112 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %93, <4 x float> %111)
%113 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %108, <4 x float> %95, <4 x float> %97)
%114 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %99, <4 x float> %113)
%115 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %101, i64 0
%116 = bitcast float* %115 to <12 x float>*
%117 = shufflevector <4 x float> %110, <4 x float> %112, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%118 = shufflevector <4 x float> %114, <4 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
%119 = shufflevector <8 x float> %117, <8 x float> %118, <12 x i32> <i32 0, i32 4, i32 8, i32 1, i32 5, i32 9, i32 2, i32 6, i32 10, i32 3, i32 7, i32 11>
store <12 x float> %119, <12 x float>* %116
%120 = add nuw i64 %101, 4
%121 = icmp eq i64 %120, %83
br i1 %121, label %122, label %100
122: ; preds = %100
%123 = icmp eq i64 %83, %72
br i1 %123, label %150, label %124
124: ; preds = %74, %53, %122
%125 = phi i64 [ 0, %74 ], [ 0, %53 ], [ %83, %122 ]
%126 = phi float* [ %67, %74 ], [ %67, %53 ], [ %85, %122 ]
%127 = extractelement <2 x float> %61, i64 0
%128 = extractelement <2 x float> %58, i64 0
%129 = extractelement <2 x float> %61, i64 1
%130 = extractelement <2 x float> %58, i64 1
br label %131
131: ; preds = %124, %131
%132 = phi i64 [ %148, %131 ], [ %125, %124 ]
%133 = phi float* [ %136, %131 ], [ %126, %124 ]
%134 = getelementptr inbounds float, float* %133, i64 1
%135 = load float, float* %133
%136 = getelementptr inbounds float, float* %133, i64 2
%137 = load float, float* %134
%138 = fneg float %135
%139 = call float @llvm.fmuladd.f32(float %138, float %128, float %127)
%140 = call float @llvm.fmuladd.f32(float %137, float %68, float %139)
%141 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %132, i64 0
store float %140, float* %141
%142 = call float @llvm.fmuladd.f32(float %138, float %130, float %129)
%143 = call float @llvm.fmuladd.f32(float %137, float %69, float %142)
%144 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %132, i64 1
store float %143, float* %144
%145 = call float @llvm.fmuladd.f32(float %138, float %62, float %63)
%146 = call float @llvm.fmuladd.f32(float %137, float %70, float %145)
%147 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %132, i64 2
store float %146, float* %147
%148 = add nuw nsw i64 %132, 1
%149 = icmp eq i64 %148, %72
br i1 %149, label %150, label %131
150: ; preds = %131, %122
%151 = call i32 @polyline(float** %18, i32 %65)
br label %152
152: ; preds = %48, %150
%153 = phi float [ %63, %150 ], [ %36, %48 ]
%154 = phi <2 x float> [ %61, %150 ], [ %37, %48 ]
%155 = icmp sgt i64 %35, 1
br i1 %155, label %34, label %278
156: ; preds = %24, %273
%157 = phi i64 [ 0, %24 ], [ %276, %273 ]
%158 = phi float [ %3, %24 ], [ %274, %273 ]
%159 = phi <2 x float> [ %32, %24 ], [ %275, %273 ]
%160 = getelementptr inbounds i8, i8* %0, i64 %157
%161 = load i8, i8* %160
%162 = sext i8 %161 to i64
switch i8 %161, label %168 [
i8 45, label %173
i8 46, label %163
i8 87, label %164
i8 78, label %165
i8 83, label %166
i8 69, label %167
]
163: ; preds = %156
br label %173
164: ; preds = %156
br label %173
165: ; preds = %156
br label %173
166: ; preds = %156
br label %173
167: ; preds = %156
br label %173
168: ; preds = %156
%169 = add i8 %161, -48
%170 = icmp ult i8 %169, 10
br i1 %170, label %171, label %273
171: ; preds = %168
%172 = add nsw i64 %162, 4294967248
br label %173
173: ; preds = %164, %166, %171, %167, %165, %163, %156
%174 = phi i64 [ 11, %163 ], [ 12, %164 ], [ 14, %165 ], [ 15, %166 ], [ 13, %167 ], [ %172, %171 ], [ 10, %156 ]
%175 = and i64 %174, 4294967295
%176 = getelementptr inbounds [16 x i32], [16 x i32]* @plot_string.verts, i64 0, i64 %175
%177 = load i32, i32* %176
%178 = getelementptr inbounds [16 x float*], [16 x float*]* @plot_string.index, i64 0, i64 %175
%179 = load float*, float** %178
%180 = load float, float* %4
%181 = load float, float* %5
%182 = load float, float* %25
%183 = load float, float* %26
%184 = load float, float* %27
%185 = load float, float* %28
%186 = call i32 @llvm.smax.i32(i32 %177, i32 1)
%187 = zext i32 %186 to i64
%188 = icmp ult i32 %186, 4
br i1 %188, label %240, label %189
189: ; preds = %173
%190 = getelementptr [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %187, i64 0
%191 = shl nuw nsw i64 %187, 1
%192 = getelementptr float, float* %179, i64 %191
%193 = bitcast float* %192 to [100 x [3 x float]]*
%194 = icmp ult [100 x [3 x float]]* %8, %193
%195 = icmp ult float* %179, %190
%196 = and i1 %194, %195
br i1 %196, label %240, label %197
197: ; preds = %189
%198 = and i64 %187, 2147483644
%199 = shl nuw nsw i64 %198, 1
%200 = getelementptr float, float* %179, i64 %199
%201 = insertelement <4 x float> poison, float %180, i64 0
%202 = shufflevector <4 x float> %201, <4 x float> poison, <4 x i32> zeroinitializer
%203 = shufflevector <2 x float> %159, <2 x float> undef, <4 x i32> zeroinitializer
%204 = insertelement <4 x float> poison, float %181, i64 0
%205 = shufflevector <4 x float> %204, <4 x float> poison, <4 x i32> zeroinitializer
%206 = insertelement <4 x float> poison, float %182, i64 0
%207 = shufflevector <4 x float> %206, <4 x float> poison, <4 x i32> zeroinitializer
%208 = shufflevector <2 x float> %159, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
%209 = insertelement <4 x float> poison, float %183, i64 0
%210 = shufflevector <4 x float> %209, <4 x float> poison, <4 x i32> zeroinitializer
%211 = insertelement <4 x float> poison, float %184, i64 0
%212 = shufflevector <4 x float> %211, <4 x float> poison, <4 x i32> zeroinitializer
%213 = insertelement <4 x float> poison, float %158, i64 0
%214 = shufflevector <4 x float> %213, <4 x float> poison, <4 x i32> zeroinitializer
%215 = insertelement <4 x float> poison, float %185, i64 0
%216 = shufflevector <4 x float> %215, <4 x float> poison, <4 x i32> zeroinitializer
br label %217
217: ; preds = %217, %197
%218 = phi i64 [ 0, %197 ], [ %236, %217 ]
%219 = shl i64 %218, 1
%220 = getelementptr float, float* %179, i64 %219
%221 = bitcast float* %220 to <8 x float>*
%222 = load <8 x float>, <8 x float>* %221
%223 = shufflevector <8 x float> %222, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%224 = shufflevector <8 x float> %222, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%225 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %223, <4 x float> %202, <4 x float> %203)
%226 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %224, <4 x float> %205, <4 x float> %225)
%227 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %223, <4 x float> %207, <4 x float> %208)
%228 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %224, <4 x float> %210, <4 x float> %227)
%229 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %223, <4 x float> %212, <4 x float> %214)
%230 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %224, <4 x float> %216, <4 x float> %229)
%231 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %218, i64 0
%232 = bitcast float* %231 to <12 x float>*
%233 = shufflevector <4 x float> %226, <4 x float> %228, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%234 = shufflevector <4 x float> %230, <4 x float> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
%235 = shufflevector <8 x float> %233, <8 x float> %234, <12 x i32> <i32 0, i32 4, i32 8, i32 1, i32 5, i32 9, i32 2, i32 6, i32 10, i32 3, i32 7, i32 11>
store <12 x float> %235, <12 x float>* %232
%236 = add nuw i64 %218, 4
%237 = icmp eq i64 %236, %198
br i1 %237, label %238, label %217
238: ; preds = %217
%239 = icmp eq i64 %198, %187
br i1 %239, label %263, label %240
240: ; preds = %189, %173, %238
%241 = phi i64 [ 0, %189 ], [ 0, %173 ], [ %198, %238 ]
%242 = phi float* [ %179, %189 ], [ %179, %173 ], [ %200, %238 ]
%243 = extractelement <2 x float> %159, i64 0
%244 = extractelement <2 x float> %159, i64 1
br label %245
245: ; preds = %240, %245
%246 = phi i64 [ %261, %245 ], [ %241, %240 ]
%247 = phi float* [ %250, %245 ], [ %242, %240 ]
%248 = getelementptr inbounds float, float* %247, i64 1
%249 = load float, float* %247
%250 = getelementptr inbounds float, float* %247, i64 2
%251 = load float, float* %248
%252 = call float @llvm.fmuladd.f32(float %249, float %180, float %243)
%253 = call float @llvm.fmuladd.f32(float %251, float %181, float %252)
%254 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %246, i64 0
store float %253, float* %254
%255 = call float @llvm.fmuladd.f32(float %249, float %182, float %244)
%256 = call float @llvm.fmuladd.f32(float %251, float %183, float %255)
%257 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %246, i64 1
store float %256, float* %257
%258 = call float @llvm.fmuladd.f32(float %249, float %184, float %158)
%259 = call float @llvm.fmuladd.f32(float %251, float %185, float %258)
%260 = getelementptr inbounds [100 x [3 x float]], [100 x [3 x float]]* %8, i64 0, i64 %246, i64 2
store float %259, float* %260
%261 = add nuw nsw i64 %246, 1
%262 = icmp eq i64 %261, %187
br i1 %262, label %263, label %245
263: ; preds = %245, %238
%264 = call i32 @polyline(float** %29, i32 %177)
%265 = getelementptr inbounds [16 x float], [16 x float]* @plot_string.width, i64 0, i64 %175
%266 = load float, float* %265
%267 = load <2 x float>, <2 x float>* %33
%268 = insertelement <2 x float> poison, float %266, i64 0
%269 = shufflevector <2 x float> %268, <2 x float> poison, <2 x i32> zeroinitializer
%270 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %269, <2 x float> %267, <2 x float> %159)
%271 = load float, float* %27
%272 = call float @llvm.fmuladd.f32(float %266, float %271, float %158)
br label %273
273: ; preds = %168, %263
%274 = phi float [ %272, %263 ], [ %158, %168 ]
%275 = phi <2 x float> [ %270, %263 ], [ %159, %168 ]
%276 = add nuw nsw i64 %157, 1
%277 = icmp eq i64 %276, %30
br i1 %277, label %278, label %156
278: ; preds = %152, %273, %13, %23
ret void
}