LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R3Brdf.cpp
// Function: gaps::R3Brdf::UpdateFlags(gaps::RNFlags)
void R3Brdf::
UpdateFlags (const RNFlags flags)
{
    // Update flags
    this->flags = flags;
    if (!ambient.IsBlack()) this->flags.Add(R3_BRDF_AMBIENT_FLAG);
    if (!diffuse.IsBlack()) this->flags.Add(R3_BRDF_DIFFUSE_FLAG);
    if (!specular.IsBlack()) this->flags.Add(R3_BRDF_SPECULAR_FLAG);
    if (!transmission.IsBlack()) this->flags.Add(R3_BRDF_TRANSPARENCY_FLAG);
    if (!emission.IsBlack()) this->flags.Add(R3_BRDF_EMISSION_FLAG);
    if (shininess != 0.0) this->flags.Add(R3_BRDF_SHININESS_FLAG);
}

// Assembly:
subq $0x78, %rsp
movq %rsi, 0x70(%rsp)
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xa8(%rdi)
addq $0x20, %rdi
callq 0x48dd0
cmpl $0x0, %eax
jne 0x652f0
movq 0x30(%rsp), %rax
addq $0xa8, %rax
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0x2b520
movq 0x28(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x4a400
movq 0x30(%rsp), %rdi
addq $0x38, %rdi
callq 0x48dd0
cmpl $0x0, %eax
jne 0x65331
movq 0x30(%rsp), %rax
addq $0xa8, %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
movl $0x2, %esi
callq 0x2b520
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x4a400
movq 0x30(%rsp), %rdi
addq $0x50, %rdi
callq 0x48dd0
cmpl $0x0, %eax
jne 0x65372
movq 0x30(%rsp), %rax
addq $0xa8, %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
movl $0x4, %esi
callq 0x2b520
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x4a400
movq 0x30(%rsp), %rdi
addq $0x68, %rdi
callq 0x48dd0
cmpl $0x0, %eax
jne 0x653b3
movq 0x30(%rsp), %rax
addq $0xa8, %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x20, %esi
callq 0x2b520
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4a400
movq 0x30(%rsp), %rdi
addq $0x80, %rdi
callq 0x48dd0
cmpl $0x0, %eax
jne 0x653f7
movq 0x30(%rsp), %rax
addq $0xa8, %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movl $0x8, %esi
callq 0x2b520
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x4a400
movq 0x30(%rsp), %rax
movsd 0x98(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x65411
jp 0x65411
jmp 0x6543d
movq 0x30(%rsp), %rax
addq $0xa8, %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
movl $0x10, %esi
callq 0x2b520
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4a400
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::R2Texture(gaps::R2Texture const&, char const*)
R2Texture::
R2Texture(const R2Texture& texture, const char *name)
  : scene(NULL),
    scene_index(-1),
    name(NULL),
    filename((texture.filename) ? RNStrdup(texture.filename) : NULL),
    image(texture.image),
    s_wrap(texture.s_wrap),
    t_wrap(texture.t_wrap),
    min_filter(texture.min_filter),
    mag_filter(texture.mag_filter),
    blend(texture.blend),
    flags(texture.flags),
    id((texture.image) ? -1 : 0)
{
    // Set name
    if (name) this->name = RNStrdup(name);

    // Update texture                                                                                                   
    Update();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, (%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6581d
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xf3800
movq %rax, 0x8(%rsp)
jmp 0x65826
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x65826
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq %rdx, (%rcx)
movq 0x28(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq 0x28(%rsp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq 0x28(%rsp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x30(%rax)
movq 0x28(%rsp), %rcx
movl 0x34(%rcx), %ecx
movl %ecx, 0x34(%rax)
movq 0x28(%rsp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x38(%rax)
movq 0x28(%rsp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq 0x28(%rsp), %rcx
movq 0x20(%rcx), %rsi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq $0x0, %rsi
cmovnel %edx, %ecx
movl %ecx, 0x48(%rax)
cmpq $0x0, 0x20(%rsp)
je 0x658c1
movq 0x20(%rsp), %rdi
callq 0xf3800
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rdi
callq 0x658d0
addq $0x38, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::R2Texture(gaps::R2Image const*, gaps::R2TextureWrap, gaps::R2TextureWrap, gaps::R2TextureFilter, gaps::R2TextureFilter, gaps::R2TextureBlend, char const*)
R2Texture::
R2Texture(const R2Image *image,
  R2TextureWrap s_wrap, R2TextureWrap t_wrap,
  R2TextureFilter min_filter, R2TextureFilter mag_filter,
  R2TextureBlend blend,
  const char *name)
  : scene(NULL),
    scene_index(-1),
    name(NULL),
    filename(NULL),
    image(image),
    s_wrap(s_wrap),
    t_wrap(t_wrap),
    min_filter(min_filter),
    mag_filter(mag_filter),
    blend(blend),
    flags(RN_NO_FLAGS),
    id(-1)
{
    // Set name
    if (name) this->name = RNStrdup(name);

    // Update texture
    Update();
}

// Assembly:
subq $0x28, %rsp
movq 0x38(%rsp), %rax
movl 0x30(%rsp), %eax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, (%rdi)
movl $0xffffffff, 0x8(%rdi)  # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rdi)
movl 0x14(%rsp), %eax
movl %eax, 0x28(%rdi)
movl 0x10(%rsp), %eax
movl %eax, 0x2c(%rdi)
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rdi)
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rdi)
movl 0x30(%rsp), %eax
movl %eax, 0x38(%rdi)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b520
movq (%rsp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
cmpq $0x0, 0x38(%rsp)
je 0x659c1
movq 0x38(%rsp), %rdi
callq 0xf3800
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rdi
callq 0x658d0
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::R2Texture(char const*, gaps::R2TextureWrap, gaps::R2TextureWrap, gaps::R2TextureFilter, gaps::R2TextureFilter, gaps::R2TextureBlend, char const*)
R2Texture::
R2Texture(const char *filename,
  R2TextureWrap s_wrap, R2TextureWrap t_wrap,
  R2TextureFilter min_filter, R2TextureFilter mag_filter,
  R2TextureBlend blend,
  const char *name)
  : scene(NULL),
    scene_index(-1),
    name(NULL),
    filename((filename) ? RNStrdup(filename) : NULL),
    image(NULL),
    s_wrap(s_wrap),
    t_wrap(t_wrap),
    min_filter(min_filter),
    mag_filter(mag_filter),
    blend(blend),
    flags(RN_NO_FLAGS),
    id(-1)
{
    // Set name
    if (name) this->name = RNStrdup(name);

    // Create image
    image = new R2Image(filename);
    assert(image);

    // Update 
    if (!image) id = 0;
    Update();
}

// Assembly:
subq $0x58, %rsp
movq 0x68(%rsp), %rax
movl 0x60(%rsp), %eax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movl %r8d, 0x3c(%rsp)
movl %r9d, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, (%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq $0x0, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x65a3b
movq 0x48(%rsp), %rdi
callq 0xf3800
movq %rax, 0x10(%rsp)
jmp 0x65a44
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x65a44
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x20(%rdi)
movl 0x44(%rsp), %eax
movl %eax, 0x28(%rdi)
movl 0x40(%rsp), %eax
movl %eax, 0x2c(%rdi)
movl 0x3c(%rsp), %eax
movl %eax, 0x30(%rdi)
movl 0x38(%rsp), %eax
movl %eax, 0x34(%rdi)
movl 0x60(%rsp), %eax
movl %eax, 0x38(%rdi)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2b520
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
cmpq $0x0, 0x68(%rsp)
je 0x65ab8
movq 0x68(%rsp), %rdi
callq 0xf3800
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x18, %edi
callq 0x229e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
callq 0xe5760
jmp 0x65ad9
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x65b1b
movq 0x18(%rsp), %rax
movl $0x0, 0x48(%rax)
jmp 0x65b1b
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
movl $0x18, %esi
callq 0x22a00
jmp 0x65b2a
movq 0x18(%rsp), %rdi
callq 0x658d0
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x23290
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::~R2Texture()
R2Texture::
~R2Texture(void)
{
  // Unload texture
  if (IsLoaded() > 0) Unload();

  // Remove from scene
  if (scene) scene->RemoveTexture(this);

  // Free name
  if (name) free(name);

  // Free filename
  if (filename) free(filename);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x661c0
movl %eax, 0xc(%rsp)
jmp 0x65b5d
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jle 0x65b73
movq (%rsp), %rdi
callq 0x65bd0
jmp 0x65b71
jmp 0x65b73
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x65b8d
movq (%rsp), %rsi
movq (%rsi), %rdi
callq 0x2ce20
jmp 0x65b8b
jmp 0x65b8d
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x65ba5
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x22c30
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x65bbd
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x22c30
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x49a50
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::Unload() const
void R2Texture::
Unload(void) const
{
  // Check id
  if (!IsLoaded()) return;
  assert(id > 0);
  assert(image);
  
  // Delete texture
  GLuint i = id;
  glDeleteTextures(1, &i);

  // Reset texture id
  ((R2Texture *) this)->id = -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x661c0
cmpl $0x0, %eax
jne 0x65bee
jmp 0x65c13
movq (%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x1, %edi
leaq 0xc(%rsp), %rsi
callq 0x22e20
movq (%rsp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::SetFilename(char const*)
void R2Texture::
SetFilename(const char *filename)
{
  // Set filename
  if (this->filename) free(this->filename);
  if (filename) this->filename = RNStrdup(filename);
  else this->filename = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rax)
je 0x65cab
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x22c30
cmpq $0x0, 0x8(%rsp)
je 0x65cca
movq 0x8(%rsp), %rdi
callq 0xf3800
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x65cd6
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::SetImage(gaps::R2Image const*)
void R2Texture::
SetImage(const R2Image *image)
{
  // Unload previous texture
  if (IsLoaded()) Unload();

  // Set image
  flags.Remove(R2_TEXTURE_TRANSPARENCY_FLAG);
  if ((image) && ((image->NComponents() == 2) || (image->NComponents() == 4)))
    flags.Add(R2_TEXTURE_TRANSPARENCY_FLAG);
  this->image = image;
  this->id = (image) ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x661c0
cmpl $0x0, %eax
je 0x65d0c
movq 0x10(%rsp), %rdi
callq 0x65bd0
movq 0x10(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2b520
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4ed40
cmpq $0x0, 0x28(%rsp)
je 0x65d88
movq 0x28(%rsp), %rdi
callq 0x661e0
cmpl $0x2, %eax
je 0x65d5e
movq 0x28(%rsp), %rdi
callq 0x661e0
cmpl $0x4, %eax
jne 0x65d88
movq 0x10(%rsp), %rax
addq $0x40, %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2b520
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4a400
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x28(%rsp), %rsi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq $0x0, %rsi
cmovnel %edx, %ecx
movl %ecx, 0x48(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::UpdateFlags(gaps::RNFlags)
void R2Texture::
UpdateFlags (const RNFlags flags)
{
  // Update flags
  this->flags = flags;
  if ((image) && ((image->NComponents() == 2) || (image->NComponents() == 4)))
    this->flags.Add(R2_TEXTURE_TRANSPARENCY_FLAG);
}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x40(%rax)
cmpq $0x0, 0x20(%rax)
je 0x65e38
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x661e0
cmpl $0x2, %eax
je 0x65e0e
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x661e0
cmpl $0x4, %eax
jne 0x65e38
movq 0x8(%rsp), %rax
addq $0x40, %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2b520
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4a400
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Graphics/R2Texture.cpp
// Function: gaps::R2Texture::Draw(int) const
void R2Texture::
Draw(RNBoolean force) const
{
  // Check if same texture as last time
  static const R2Texture *R2current_texture = NULL;
  if (!force && (this == R2current_texture)) return;

  // Check if null texture
  if (id == 0) {
    // Disable texture
    glDisable(GL_TEXTURE_2D);

    // Disable polygon offset
    glDisable(GL_POLYGON_OFFSET_FILL);
  }
  else {
    // Load texture
    if (!IsLoaded()) Load();
    
    // Set texture
    glBindTexture(GL_TEXTURE_2D, id);

    // Enable texture
    glEnable(GL_TEXTURE_2D);

    // Enable polygon offset (for decals)
    glPolygonOffset(-1, -1);
    glEnable(GL_POLYGON_OFFSET_FILL);
  }

  // Set blending
  if (IsTransparent()) {
    glDepthMask(FALSE);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
  }
  else {
    glDisable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_ZERO);
    glDepthMask(TRUE);
  }
  
  // Remember current texture
  R2current_texture = this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x660ef
movq (%rsp), %rax
cmpq 0x197308(%rip), %rax    # 0x1fd3f0
jne 0x660ef
jmp 0x661b6
movq (%rsp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x6610f
movl $0xde1, %edi            # imm = 0xDE1
callq 0x22230
movl $0x8037, %edi           # imm = 0x8037
callq 0x22230
jmp 0x6615b
movq (%rsp), %rdi
callq 0x661c0
cmpl $0x0, %eax
jne 0x66126
movq (%rsp), %rdi
callq 0x65e40
movq (%rsp), %rax
movl 0x48(%rax), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq 0x22ce0
movl $0xde1, %edi            # imm = 0xDE1
callq 0x22910
movss 0x129d6f(%rip), %xmm1   # 0x18feb8
movaps %xmm1, %xmm0
callq 0x23140
movl $0x8037, %edi           # imm = 0x8037
callq 0x22910
movq (%rsp), %rdi
callq 0x66230
cmpl $0x0, %eax
je 0x6618b
xorl %edi, %edi
callq 0x225b0
movl $0x302, %edi            # imm = 0x302
movl $0x303, %esi            # imm = 0x303
callq 0x22790
movl $0xbe2, %edi            # imm = 0xBE2
callq 0x22910
jmp 0x661ab
movl $0xbe2, %edi            # imm = 0xBE2
callq 0x22230
movl $0x1, %edi
xorl %esi, %esi
callq 0x22790
movl $0x1, %edi
callq 0x225b0
movq (%rsp), %rax
movq %rax, 0x19723a(%rip)    # 0x1fd3f0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R3Shapes/R3Shapes.cpp
// Function: gaps::R3InitShapes()
int R3InitShapes(void)
{
    // Check whether are already initialized 
    if ((R3shapes_active_count++) > 0) return TRUE;

    // Initialize dependencies
    if (!R2InitShapes()) return FALSE;

    // Initialize submodules 
    if (!R3InitCircle()) return FALSE;

    // return OK status 
    return TRUE;
}

// Assembly:
pushq %rax
movl 0x197181(%rip), %eax    # 0x1fd3f8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x197176(%rip)    # 0x1fd3f8
cmpl $0x0, %eax
jle 0x66291
movl $0x1, 0x4(%rsp)
jmp 0x662c1
callq 0xdb470
cmpl $0x0, %eax
jne 0x662a5
movl $0x0, 0x4(%rsp)
jmp 0x662c1
callq 0xabdb0
cmpl $0x0, %eax
jne 0x662b9
movl $0x0, 0x4(%rsp)
jmp 0x662c1
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/R2Shapes/R2Shapes.cpp
// Function: gaps::R2InitShapes()
int R2InitShapes(void)
{
    // Check whether are already initialized 
    if ((R2shapes_active_count++) > 0) return TRUE;

    // Initialize dependencies
    if (!RNInitBasics()) return FALSE;

    // Initialize submodules 
    if (!R2InitCircle()) return FALSE;

    // return OK status 
    return TRUE;
}

// Assembly:
pushq %rax
movl 0x123f49(%rip), %eax    # 0x1ff3c0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x123f3e(%rip)    # 0x1ff3c0
cmpl $0x0, %eax
jle 0xdb491
movl $0x1, 0x4(%rsp)
jmp 0xdb4c1
callq 0xeeb00
cmpl $0x0, %eax
jne 0xdb4a5
movl $0x0, 0x4(%rsp)
jmp 0xdb4c1
callq 0xdffb0
cmpl $0x0, %eax
jne 0xdb4b9
movl $0x0, 0x4(%rsp)
jmp 0xdb4c1
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_callbacks.c
// Function: glutDisplayFunc
void FGAPIENTRY glutDisplayFunc( void (* callback)( void ) )
{
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutDisplayFunc" );
    if( !callback )
        fgError( "Fatal error in program.  NULL display callback not "
                 "permitted in GLUT 3.0+ or freeglut 2.0.1+" );
    SET_CALLBACK( Display );
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
leaq 0x811f4(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x1791b7
leaq 0x24729(%rip), %rdi     # 0x19d8d2
leaq 0x24762(%rip), %rsi     # 0x19d912
movb $0x0, %al
callq 0x17de70
cmpq $0x0, (%rsp)
jne 0x1791cc
leaq 0x2475d(%rip), %rdi     # 0x19d922
movb $0x0, %al
callq 0x17de70
jmp 0x1791ce
leaq 0x86d0b(%rip), %rax     # 0x1ffee0
cmpq $0x0, 0x30(%rax)
jne 0x1791de
jmp 0x17920c
jmp 0x1791e0
leaq 0x86cf9(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq 0x70(%rax), %rax
cmpq (%rsp), %rax
je 0x179208
movq (%rsp), %rcx
leaq 0x86ce0(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq %rcx, 0x70(%rax)
jmp 0x17920a
jmp 0x17920c
popq %rax
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_callbacks.c
// Function: glutTimerFunc
void FGAPIENTRY glutTimerFunc( unsigned int timeOut, void (* callback)( int ),
                               int timerID )
{
    SFG_Timer *timer, *node;

    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutTimerFunc" );

    if( (timer = fgState.FreeTimers.Last) )
    {
        fgListRemove( &fgState.FreeTimers, &timer->Node );
    }
    else
    {
        if( ! (timer = malloc(sizeof(SFG_Timer))) )
            fgError( "Fatal error: "
                     "Memory allocation failure in glutTimerFunc()" );
    }

    timer->Callback  = callback;
    timer->ID        = timerID;
    timer->TriggerTime = fgElapsedTime() + timeOut;

    for( node = fgState.Timers.First; node; node = node->Node.Next )
    {
        if( node->TriggerTime > timer->TriggerTime )
            break;
    }

    fgListInsert( &fgState.Timers, &node->Node, &timer->Node );
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
leaq 0x80fd8(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x1793d3
leaq 0x2450d(%rip), %rdi     # 0x19d8d2
leaq 0x245f1(%rip), %rsi     # 0x19d9bd
movb $0x0, %al
callq 0x17de70
leaq 0x80fb6(%rip), %rax     # 0x1fa390
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x179400
movq 0x8(%rsp), %rsi
leaq 0x80f9b(%rip), %rdi     # 0x1fa390
addq $0x58, %rdi
callq 0x182ae0
jmp 0x179425
movl $0x28, %edi
callq 0x22df0
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x179423
leaq 0x245af(%rip), %rdi     # 0x19d9cb
movb $0x0, %al
callq 0x17de70
jmp 0x179425
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
callq 0x17de50
movq %rax, %rcx
movl 0x24(%rsp), %eax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
leaq 0x80f32(%rip), %rax     # 0x1fa390
movq 0x48(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x179491
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jle 0x179482
jmp 0x179491
jmp 0x179484
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x179466
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x80eef(%rip), %rdi     # 0x1fa390
addq $0x48, %rdi
callq 0x183220
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_callbacks.c
// Function: glutVisibilityFunc
void FGAPIENTRY glutVisibilityFunc( void (* callback)( int ) )
{
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutVisibilityFunc" );
    SET_CALLBACK( Visibility );

    if( callback )
        glutWindowStatusFunc( fghVisibility );
    else
        glutWindowStatusFunc( NULL );
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
leaq 0x80ed4(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x1794d7
leaq 0x24409(%rip), %rdi     # 0x19d8d2
leaq 0x24535(%rip), %rsi     # 0x19da05
movb $0x0, %al
callq 0x17de70
jmp 0x1794d9
leaq 0x86a00(%rip), %rax     # 0x1ffee0
cmpq $0x0, 0x30(%rax)
jne 0x1794e9
jmp 0x17953b
jmp 0x1794eb
leaq 0x869ee(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq 0xc8(%rax), %rax
cmpq (%rsp), %rax
je 0x179519
movq (%rsp), %rcx
leaq 0x869d2(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq %rcx, 0xc8(%rax)
jmp 0x17951b
jmp 0x17951d
cmpq $0x0, (%rsp)
je 0x179532
leaq 0x85(%rip), %rdi        # 0x1795b0
callq 0x179540
jmp 0x17953b
xorl %eax, %eax
movl %eax, %edi
callq 0x179540
popq %rax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_callbacks.c
// Function: fghVisibility
static void fghVisibility( int status )
{
    int glut_status = GLUT_VISIBLE;

    FREEGLUT_INTERNAL_ERROR_EXIT_IF_NOT_INITIALISED ( "Visibility Callback" );
    freeglut_return_if_fail( fgStructure.CurrentWindow );

    if( ( GLUT_HIDDEN == status )  || ( GLUT_FULLY_COVERED == status ) )
        glut_status = GLUT_NOT_VISIBLE;
    INVOKE_WCB( *( fgStructure.CurrentWindow ), Visibility, ( glut_status ) );
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movl $0x1, (%rsp)
leaq 0x80dcd(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x1795de
leaq 0x245e7(%rip), %rdi     # 0x19dbb7
leaq 0x24629(%rip), %rsi     # 0x19dc00
movb $0x0, %al
callq 0x17de70
leaq 0x868fb(%rip), %rax     # 0x1ffee0
cmpq $0x0, 0x30(%rax)
jne 0x1795ee
jmp 0x179648
xorl %eax, %eax
cmpl 0x4(%rsp), %eax
je 0x179601
movl $0x3, %eax
cmpl 0x4(%rsp), %eax
jne 0x179608
movl $0x0, (%rsp)
jmp 0x17960a
leaq 0x868cf(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
cmpq $0x0, 0xc8(%rax)
je 0x179646
leaq 0x868ba(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rdi
callq 0x1838e0
leaq 0x868aa(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq 0xc8(%rax), %rax
movl (%rsp), %edi
callq *%rax
jmp 0x179648
popq %rax
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_callbacks.c
// Function: glutJoystickFunc
void FGAPIENTRY glutJoystickFunc( void (* callback)
                                  ( unsigned int, int, int, int ),
                                  int pollInterval )
{
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutJoystickFunc" );
    fgInitialiseJoysticks ();

    SET_CALLBACK( Joystick );
    fgStructure.CurrentWindow->State.JoystickPollRate = pollInterval;

    fgStructure.CurrentWindow->State.JoystickLastPoll =
        fgElapsedTime() - fgStructure.CurrentWindow->State.JoystickPollRate;

    if( fgStructure.CurrentWindow->State.JoystickLastPoll < 0 )
        fgStructure.CurrentWindow->State.JoystickLastPoll = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
leaq 0x80c4c(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17975f
leaq 0x24181(%rip), %rdi     # 0x19d8d2
leaq 0x242e5(%rip), %rsi     # 0x19da3d
movb $0x0, %al
callq 0x17de70
callq 0x17cd60
leaq 0x86775(%rip), %rax     # 0x1ffee0
cmpq $0x0, 0x30(%rax)
jne 0x179777
jmp 0x17980c
jmp 0x179779
leaq 0x86760(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq 0xd8(%rax), %rax
cmpq 0x10(%rsp), %rax
je 0x1797a9
movq 0x10(%rsp), %rcx
leaq 0x86742(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq %rcx, 0xd8(%rax)
jmp 0x1797ab
jmp 0x1797ad
movslq 0xc(%rsp), %rcx
leaq 0x86727(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq %rcx, 0x50(%rax)
callq 0x17de50
movq %rax, %rcx
leaq 0x86710(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
subq 0x50(%rax), %rcx
leaq 0x86701(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq %rcx, 0x58(%rax)
leaq 0x866f2(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
cmpq $0x0, 0x58(%rax)
jge 0x17980c
leaq 0x866e0(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq $0x0, 0x58(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_display.c
// Function: glutPostWindowRedisplay
void FGAPIENTRY glutPostWindowRedisplay( int windowID )
{
    SFG_Window* window;

    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPostWindowRedisplay" );
    window = fgWindowByID( windowID );
    freeglut_return_if_fail( window );
    window->State.Redisplay = GL_TRUE;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
leaq 0x80211(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17a19a
leaq 0x23746(%rip), %rdi     # 0x19d8d2
leaq 0x23b15(%rip), %rsi     # 0x19dca8
movb $0x0, %al
callq 0x17de70
movl 0x14(%rsp), %edi
callq 0x1830b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17a1b2
jmp 0x17a1bb
movq 0x8(%rsp), %rax
movb $0x1, 0x48(%rax)
addq $0x18, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutBitmapCharacter
void FGAPIENTRY glutBitmapCharacter( void* fontID, int character )
{
    const GLubyte* face;
    SFG_Font* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapCharacter" );
    font = fghFontByID( fontID );
    freeglut_return_if_fail( ( character >= 1 )&&( character < 256 ) );
    freeglut_return_if_fail( font );

    /*
     * Find the character we want to draw (???)
     */
    face = font->Characters[ character ];

    glPushClientAttrib( GL_CLIENT_PIXEL_STORE_BIT );
    glPixelStorei( GL_UNPACK_SWAP_BYTES,  GL_FALSE );
    glPixelStorei( GL_UNPACK_LSB_FIRST,   GL_FALSE );
    glPixelStorei( GL_UNPACK_ROW_LENGTH,  0        );
    glPixelStorei( GL_UNPACK_SKIP_ROWS,   0        );
    glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0        );
    glPixelStorei( GL_UNPACK_ALIGNMENT,   1        );
    glBitmap(
        face[ 0 ], font->Height,      /* The bitmap's width and height  */
        font->xorig, font->yorig,     /* The origin in the font glyph   */
        ( float )( face[ 0 ] ), 0.0,  /* The raster advance -- inc. x,y */
        ( face + 1 )                  /* The packed bitmap data...      */
    );
    glPopClientAttrib( );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
leaq 0x801bc(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17a1ef
leaq 0x236f1(%rip), %rdi     # 0x19d8d2
leaq 0x23ad8(%rip), %rsi     # 0x19dcc0
movb $0x0, %al
callq 0x17de70
movq 0x20(%rsp), %rdi
callq 0x17a2d0
movq %rax, 0x8(%rsp)
cmpl $0x1, 0x1c(%rsp)
jl 0x17a20f
cmpl $0x100, 0x1c(%rsp)      # imm = 0x100
jl 0x17a214
jmp 0x17a2cb
cmpq $0x0, 0x8(%rsp)
jne 0x17a221
jmp 0x17a2cb
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %edi
movl %edi, 0x4(%rsp)
callq 0x226c0
movl $0xcf0, %edi            # imm = 0xCF0
xorl %esi, %esi
movl %esi, (%rsp)
callq 0x22490
movl (%rsp), %esi
movl $0xcf1, %edi            # imm = 0xCF1
callq 0x22490
movl (%rsp), %esi
movl $0xcf2, %edi            # imm = 0xCF2
callq 0x22490
movl (%rsp), %esi
movl $0xcf3, %edi            # imm = 0xCF3
callq 0x22490
movl (%rsp), %esi
movl $0xcf4, %edi            # imm = 0xCF4
callq 0x22490
movl 0x4(%rsp), %esi
movl $0xcf5, %edi            # imm = 0xCF5
callq 0x22490
movq 0x10(%rsp), %rax
movzbl (%rax), %edi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
movss 0x18(%rax), %xmm0
movss 0x1c(%rax), %xmm1
cvtsi2ss %edi, %xmm2
movq 0x10(%rsp), %rdx
addq $0x1, %rdx
xorps %xmm3, %xmm3
callq 0x22970
callq 0x22c20
addq $0x28, %rsp
retq
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: fghFontByID
static SFG_Font* fghFontByID( void* font )
{
    if( font == GLUT_BITMAP_8_BY_13        )
        return &fgFontFixed8x13;
    if( font == GLUT_BITMAP_9_BY_15        )
        return &fgFontFixed9x15;
    if( font == GLUT_BITMAP_HELVETICA_10   )
        return &fgFontHelvetica10;
    if( font == GLUT_BITMAP_HELVETICA_12   )
        return &fgFontHelvetica12;
    if( font == GLUT_BITMAP_HELVETICA_18   )
        return &fgFontHelvetica18;
    if( font == GLUT_BITMAP_TIMES_ROMAN_10 )
        return &fgFontTimesRoman10;
    if( font == GLUT_BITMAP_TIMES_ROMAN_24 )
        return &fgFontTimesRoman24;

    fgWarning( "font 0x%08x not found", font );
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x85ac0(%rip), %rax     # 0x1ffda0
cmpq %rax, 0x8(%rsp)
jne 0x17a2f8
leaq 0x785b2(%rip), %rax     # 0x1f28a0
movq %rax, 0x10(%rsp)
jmp 0x17a3c2
leaq 0x85a89(%rip), %rax     # 0x1ffd88
cmpq %rax, 0x8(%rsp)
jne 0x17a317
leaq 0x785b3(%rip), %rax     # 0x1f28c0
movq %rax, 0x10(%rsp)
jmp 0x17a3c2
leaq 0x85aca(%rip), %rax     # 0x1ffde8
cmpq %rax, 0x8(%rsp)
jne 0x17a336
leaq 0x785b4(%rip), %rax     # 0x1f28e0
movq %rax, 0x10(%rsp)
jmp 0x17a3c2
leaq 0x85ac3(%rip), %rax     # 0x1ffe00
cmpq %rax, 0x8(%rsp)
jne 0x17a352
leaq 0x785b5(%rip), %rax     # 0x1f2900
movq %rax, 0x10(%rsp)
jmp 0x17a3c2
leaq 0x85abf(%rip), %rax     # 0x1ffe18
cmpq %rax, 0x8(%rsp)
jne 0x17a36e
leaq 0x785b9(%rip), %rax     # 0x1f2920
movq %rax, 0x10(%rsp)
jmp 0x17a3c2
leaq 0x85a43(%rip), %rax     # 0x1ffdb8
cmpq %rax, 0x8(%rsp)
jne 0x17a38a
leaq 0x785bd(%rip), %rax     # 0x1f2940
movq %rax, 0x10(%rsp)
jmp 0x17a3c2
leaq 0x85a3f(%rip), %rax     # 0x1ffdd0
cmpq %rax, 0x8(%rsp)
jne 0x17a3a6
leaq 0x785c1(%rip), %rax     # 0x1f2960
movq %rax, 0x10(%rsp)
jmp 0x17a3c2
movq 0x8(%rsp), %rsi
leaq 0x239c3(%rip), %rdi     # 0x19dd75
movb $0x0, %al
callq 0x17dfa0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutBitmapWidth
int FGAPIENTRY glutBitmapWidth( void* fontID, int character )
{
    SFG_Font* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapWidth" );
    font = fghFontByID( fontID );
    freeglut_return_val_if_fail( character > 0 && character < 256, 0 );
    freeglut_return_val_if_fail( font, 0 );
    return *( font->Characters[ character ] );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
leaq 0x7fe1c(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17a58f
leaq 0x23351(%rip), %rdi     # 0x19d8d2
leaq 0x2375d(%rip), %rsi     # 0x19dce5
movb $0x0, %al
callq 0x17de70
movq 0x18(%rsp), %rdi
callq 0x17a2d0
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x17a5af
cmpl $0x100, 0x14(%rsp)      # imm = 0x100
jl 0x17a5b9
movl $0x0, 0x24(%rsp)
jmp 0x17a5e4
cmpq $0x0, 0x8(%rsp)
jne 0x17a5cb
movl $0x0, 0x24(%rsp)
jmp 0x17a5e4
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutBitmapLength
int FGAPIENTRY glutBitmapLength( void* fontID, const unsigned char* string )
{
    unsigned char c;
    int length = 0, this_line_length = 0;
    SFG_Font* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapLength" );
    font = fghFontByID( fontID );
    freeglut_return_val_if_fail( font, 0 );
    if ( !string || ! *string )
        return 0;

    while( ( c = *string++) )
    {
        if( c != '\n' )/* Not an EOL, increment length of line */
            this_line_length += *( font->Characters[ c ]);
        else  /* EOL; reset the length of this line */
        {
            if( length < this_line_length )
                length = this_line_length;
            this_line_length = 0;
        }
    }
    if ( length < this_line_length )
        length = this_line_length;

    return length;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
leaq 0x7fd7b(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17a630
leaq 0x232b0(%rip), %rdi     # 0x19d8d2
leaq 0x236cc(%rip), %rsi     # 0x19dcf5
movb $0x0, %al
callq 0x17de70
movq 0x28(%rsp), %rdi
callq 0x17a2d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17a654
movl $0x0, 0x34(%rsp)
jmp 0x17a6ec
cmpq $0x0, 0x20(%rsp)
je 0x17a666
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x17a670
movl $0x0, 0x34(%rsp)
jmp 0x17a6ec
jmp 0x17a672
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb (%rax), %al
movb %al, 0x1f(%rsp)
cmpb $0x0, %al
je 0x17a6d2
movzbl 0x1f(%rsp), %eax
cmpl $0xa, %eax
je 0x17a6b6
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0x1f(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movzbl (%rax), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x17a6d0
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x17a6c8
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
jmp 0x17a672
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x17a6e4
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutBitmapHeight
int FGAPIENTRY glutBitmapHeight( void* fontID )
{
    SFG_Font* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutBitmapHeight" );
    font = fghFontByID( fontID );
    freeglut_return_val_if_fail( font, 0 );
    return font->Height;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x7fc80(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17a72b
leaq 0x231b5(%rip), %rdi     # 0x19d8d2
leaq 0x235e2(%rip), %rsi     # 0x19dd06
movb $0x0, %al
callq 0x17de70
movq 0x8(%rsp), %rdi
callq 0x17a2d0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x17a74a
movl $0x0, 0x14(%rsp)
jmp 0x17a755
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutStrokeCharacter
void FGAPIENTRY glutStrokeCharacter( void* fontID, int character )
{
    const SFG_StrokeChar *schar;
    const SFG_StrokeStrip *strip;
    int i, j;
    SFG_StrokeFont* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeCharacter" );
    font = fghStrokeByID( fontID );
    freeglut_return_if_fail( character >= 0 );
    freeglut_return_if_fail( character < font->Quantity );
    freeglut_return_if_fail( font );

    schar = font->Characters[ character ];
    freeglut_return_if_fail( schar );
    strip = schar->Strips;

    for( i = 0; i < schar->Number; i++, strip++ )
    {
        glBegin( GL_LINE_STRIP );
        for( j = 0; j < strip->Number; j++ )
            glVertex2f( strip->Vertices[ j ].X, strip->Vertices[ j ].Y );
        glEnd( );
				glBegin( GL_POINTS );
        for( j = 0; j < strip->Number; j++ )
            glVertex2f( strip->Vertices[ j ].X, strip->Vertices[ j ].Y );
				glEnd( );
    }
    glTranslatef( schar->Right, 0.0, 0.0 );
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
leaq 0x7fc1c(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17a78f
leaq 0x23151(%rip), %rdi     # 0x19d8d2
leaq 0x2358f(%rip), %rsi     # 0x19dd17
movb $0x0, %al
callq 0x17de70
movq 0x30(%rsp), %rdi
callq 0x17a910
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x2c(%rsp)
jge 0x17a7aa
jmp 0x17a8ff
movl 0x2c(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x17a7bd
jmp 0x17a8ff
cmpq $0x0, 0x8(%rsp)
jne 0x17a7ca
jmp 0x17a8ff
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x17a7ee
jmp 0x17a8ff
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x17a8eb
movl $0x3, %edi
callq 0x221b0
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x17a86e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x10(%rsp), %rcx
movss (%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x10(%rsp), %rcx
movss 0x4(%rax,%rcx,8), %xmm1
callq 0x22c50
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x17a828
callq 0x22de0
xorl %edi, %edi
callq 0x221b0
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x17a8c8
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x10(%rsp), %rcx
movss (%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x10(%rsp), %rcx
movss 0x4(%rax,%rcx,8), %xmm1
callq 0x22c50
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x17a882
callq 0x22de0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
jmp 0x17a804
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm2, %xmm2
movaps %xmm2, %xmm1
callq 0x23070
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: fghStrokeByID
static SFG_StrokeFont* fghStrokeByID( void* font )
{
    if( font == GLUT_STROKE_ROMAN      )
        return &fgStrokeRoman;
    if( font == GLUT_STROKE_MONO_ROMAN )
        return &fgStrokeMonoRoman;

    fgWarning( "stroke font 0x%08x not found", font );
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x85428(%rip), %rax     # 0x1ffd48
cmpq %rax, 0x8(%rsp)
jne 0x17a935
leaq 0x78052(%rip), %rax     # 0x1f2980
movq %rax, 0x10(%rsp)
jmp 0x17a96d
leaq 0x8542c(%rip), %rax     # 0x1ffd68
cmpq %rax, 0x8(%rsp)
jne 0x17a951
leaq 0x79216(%rip), %rax     # 0x1f3b60
movq %rax, 0x10(%rsp)
jmp 0x17a96d
movq 0x8(%rsp), %rsi
leaq 0x23411(%rip), %rdi     # 0x19dd6e
movb $0x0, %al
callq 0x17dfa0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutStrokeWidth
int FGAPIENTRY glutStrokeWidth( void* fontID, int character )
{
    const SFG_StrokeChar *schar;
    SFG_StrokeFont* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeWidth" );
    font = fghStrokeByID( fontID );
    freeglut_return_val_if_fail( ( character >= 0 ) &&
                                 ( character < font->Quantity ),
                                 0
    );
    freeglut_return_val_if_fail( font, 0 );
    schar = font->Characters[ character ];
    freeglut_return_val_if_fail( schar, 0 );

    return ( int )( schar->Right + 0.5 );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
leaq 0x7f81c(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17ab8f
leaq 0x22d51(%rip), %rdi     # 0x19d8d2
leaq 0x231b4(%rip), %rsi     # 0x19dd3c
movb $0x0, %al
callq 0x17de70
movq 0x18(%rsp), %rdi
callq 0x17a910
movq %rax, (%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x17abb1
movl 0x14(%rsp), %eax
movq (%rsp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x17abbb
movl $0x0, 0x24(%rsp)
jmp 0x17ac15
cmpq $0x0, (%rsp)
jne 0x17abcc
movl $0x0, 0x24(%rsp)
jmp 0x17ac15
movq (%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17abf4
movl $0x0, 0x24(%rsp)
jmp 0x17ac15
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x13417(%rip), %xmm1    # 0x18e020
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutStrokeLength
int FGAPIENTRY glutStrokeLength( void* fontID, const unsigned char* string )
{
    unsigned char c;
    float length = 0.0;
    float this_line_length = 0.0;
    SFG_StrokeFont* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeLength" );
    font = fghStrokeByID( fontID );
    freeglut_return_val_if_fail( font, 0 );
    if ( !string || ! *string )
        return 0;

    while( ( c = *string++) )
        if( c < font->Quantity )
        {
            if( c == '\n' ) /* EOL; reset the length of this line */
            {
                if( length < this_line_length )
                    length = this_line_length;
                this_line_length = 0.0;
            }
            else  /* Not an EOL, increment the length of this line */
            {
                const SFG_StrokeChar *schar = font->Characters[ c ];
                if( schar )
                    this_line_length += schar->Right;
            }
        }
    if( length < this_line_length )
        length = this_line_length;
    return( int )( length + 0.5 );
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
leaq 0x7f749(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17ac62
leaq 0x22c7e(%rip), %rdi     # 0x19d8d2
leaq 0x230f1(%rip), %rsi     # 0x19dd4c
movb $0x0, %al
callq 0x17de70
movq 0x28(%rsp), %rdi
callq 0x17a910
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17ac86
movl $0x0, 0x34(%rsp)
jmp 0x17ad78
cmpq $0x0, 0x20(%rsp)
je 0x17ac98
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x17aca5
movl $0x0, 0x34(%rsp)
jmp 0x17ad78
jmp 0x17aca7
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb (%rax), %al
movb %al, 0x1f(%rsp)
cmpb $0x0, %al
je 0x17ad3d
movzbl 0x1f(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x17ad38
movzbl 0x1f(%rsp), %eax
cmpl $0xa, %eax
jne 0x17ad03
movss 0x18(%rsp), %xmm1
movss 0x14(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x17acf8
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x17ad36
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movzbl 0x1f(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x17ad34
movq (%rsp), %rax
movss (%rax), %xmm0
addss 0x14(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x17ad36
jmp 0x17ad38
jmp 0x17aca7
movss 0x18(%rsp), %xmm1
movss 0x14(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x17ad5a
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x18(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x132b4(%rip), %xmm1    # 0x18e020
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_font.c
// Function: glutStrokeHeight
GLfloat FGAPIENTRY glutStrokeHeight( void* fontID )
{
    SFG_StrokeFont* font;
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutStrokeHeight" );
    font = fghStrokeByID( fontID );
    freeglut_return_val_if_fail( font, 0.0 );
    return font->Height;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x7f5f0(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x17adbb
leaq 0x22b25(%rip), %rdi     # 0x19d8d2
leaq 0x22fa9(%rip), %rsi     # 0x19dd5d
movb $0x0, %al
callq 0x17de70
movq 0x8(%rsp), %rdi
callq 0x17a910
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x17addb
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x17adea
movq (%rsp), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_init.c
// Function: fgHintPresent
int fgHintPresent(Window window, Atom property, Atom hint)
{
  Atom ** atoms_ptr;
  int number_of_atoms;
  int supported;
  int i;

  supported = 0;

  atoms_ptr = malloc(sizeof(Atom *));
  number_of_atoms = fghGetWindowProperty(window,
					 property,
					 XA_ATOM,
					 (unsigned char **) atoms_ptr);
  for (i = 0; i < number_of_atoms; i++)
    {
      if ((*atoms_ptr)[i] == hint)
      {
          supported = 1;
          break;
      }
    }

  return supported;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x8, %edi
callq 0x22df0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rcx
movl $0x4, %edx
callq 0x17aea0
movl %eax, 0x14(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x17ae8a
movq 0x18(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x20(%rsp), %rax
jne 0x17ae7b
movl $0x1, 0x10(%rsp)
jmp 0x17ae8a
jmp 0x17ae7d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x17ae4f
movl 0x10(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_init.c
// Function: fghGetWindowProperty
static int fghGetWindowProperty(Window window,
				Atom property,
				Atom type,
				unsigned char ** data)
{
  /*
   * Caller always has to use "Xfree()" to free "data", since
   * "XGetWindowProperty() always allocates one extra byte in prop_return
   * [i.e. "data"] (even if the property is zero length) [..]".
   */

  int status;  /*  Returned by "XGetWindowProperty". */

  Atom          type_returned;
  int           temp_format;             /*  Not used. */
  unsigned long number_of_elements;
  unsigned long temp_bytes_after;        /*  Not used. */


  status = XGetWindowProperty(fgDisplay.Display,
			      window,
			      property,
			      0,
			      LONG_MAX,
			      False,
			      type,
			      &type_returned,
			      &temp_format,
			      &number_of_elements,
			      &temp_bytes_after,
			      data);

  FREEGLUT_INTERNAL_ERROR_EXIT(status == Success,
			       "XGetWindowProperty failled",
			       "fghGetWindowProperty");

  if (type_returned != type)
    {
      number_of_elements = 0;
    }

  return number_of_elements;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x84f69(%rip), %rdi     # 0x1ffe30
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %r15
movq 0x60(%rsp), %rax
xorl %ecx, %ecx
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
xorl %r9d, %r9d
leaq 0x50(%rsp), %r14
leaq 0x4c(%rsp), %rbx
leaq 0x40(%rsp), %r11
leaq 0x38(%rsp), %r10
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x222a0
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0x17af47
leaq 0x33318(%rip), %rdi     # 0x1ae24a
leaq 0x3333d(%rip), %rsi     # 0x1ae276
leaq 0x33351(%rip), %rdx     # 0x1ae291
movb $0x0, %al
callq 0x17de70
movq 0x50(%rsp), %rax
cmpq 0x68(%rsp), %rax
je 0x17af5c
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_init.c
// Function: glutInitWindowPosition
void FGAPIENTRY glutInitWindowPosition( int x, int y )
{
    fgState.Position.X = x;
    fgState.Position.Y = y;

    if( ( x >= 0 ) && ( y >= 0 ) )
        fgState.Position.Use = GL_TRUE;
    else
        fgState.Position.Use = GL_FALSE;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl %eax, 0x7ea0e(%rip)     # 0x1fa390
movl -0x8(%rsp), %eax
movl %eax, 0x7ea08(%rip)     # 0x1fa394
cmpl $0x0, -0x4(%rsp)
jl 0x17b9a3
cmpl $0x0, -0x8(%rsp)
jl 0x17b9a3
movb $0x1, 0x7e9f7(%rip)     # 0x1fa398
jmp 0x17b9aa
movb $0x0, 0x7e9ee(%rip)     # 0x1fa398
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_init.c
// Function: glutInitWindowSize
void FGAPIENTRY glutInitWindowSize( int width, int height )
{
    fgState.Size.X = width;
    fgState.Size.Y = height;

    if( ( width > 0 ) && ( height > 0 ) )
        fgState.Size.Use = GL_TRUE;
    else
        fgState.Size.Use = GL_FALSE;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl -0x4(%rsp), %eax
movl %eax, 0x7e9da(%rip)     # 0x1fa39c
movl -0x8(%rsp), %eax
movl %eax, 0x7e9d4(%rip)     # 0x1fa3a0
cmpl $0x0, -0x4(%rsp)
jle 0x17b9e3
cmpl $0x0, -0x8(%rsp)
jle 0x17b9e3
movb $0x1, 0x7e9c3(%rip)     # 0x1fa3a4
jmp 0x17b9ea
movb $0x0, 0x7e9ba(%rip)     # 0x1fa3a4
retq
nopl (%rax,%rax)