img_writer_emit_start (struct MonoImageWriter * acfg)
{
  asm_writer_emit_start (acfg);
}


asm_writer_emit_start (struct MonoImageWriter * acfg)
{

}


img_writer_emit_section_change (struct MonoImageWriter * acfg, const char * section_name, int subsection_index)
{
  asm_writer_emit_section_change (acfg, section_name, subsection_index);
  acfg->current_section = section_name;
  acfg->current_subsection = subsection_index;
}


asm_writer_emit_section_change (struct MonoImageWriter * acfg, const char * section_name, int subsection_index)
{
  int D.23126;
  int iftmp.0;
  int D.23125;
  const char[6] * D.23354;
  unsigned char D.23355;
  int D.23356;
  unsigned char D.23357;
  int D.23358;
  const unsigned char * D.23363;
  unsigned char D.23364;
  int D.23365;
  const unsigned char * D.23366;
  unsigned char D.23367;
  int D.23368;
  const unsigned char * D.23373;
  unsigned char D.23374;
  int D.23375;
  const unsigned char * D.23376;
  unsigned char D.23377;
  int D.23378;
  const unsigned char * D.23383;
  unsigned char D.23384;
  int D.23385;
  const unsigned char * D.23386;
  unsigned char D.23387;
  int D.23388;
  int D.23135;
  int iftmp.1;
  int D.23134;
  const char[6] * D.23394;
  unsigned char D.23395;
  int D.23396;
  unsigned char D.23397;
  int D.23398;
  const unsigned char * D.23403;
  unsigned char D.23404;
  int D.23405;
  const unsigned char * D.23406;
  unsigned char D.23407;
  int D.23408;
  const unsigned char * D.23413;
  unsigned char D.23414;
  int D.23415;
  const unsigned char * D.23416;
  unsigned char D.23417;
  int D.23418;
  const unsigned char * D.23423;
  unsigned char D.23424;
  int D.23425;
  const unsigned char * D.23426;
  unsigned char D.23427;
  int D.23428;
  struct FILE * D.23430;

  asm_writer_emit_unset_mode (acfg);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.23352>; else goto <D.23353>;
    <D.23352>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = section_name;
      D.23354 = ".text";
      D.23355 = MEM[(const unsigned char *)D.23354];
      D.23356 = (int) D.23355;
      D.23357 = *__s2;
      D.23358 = (int) D.23357;
      __result = D.23356 - D.23358;
      {
        if (__s2_len != 0) goto <D.23359>; else goto <D.23360>;
        <D.23359>:
        if (__result == 0) goto <D.23361>; else goto <D.23362>;
        <D.23361>:
        D.23363 = &MEM[(void *)".text" + 1B];
        D.23364 = *D.23363;
        D.23365 = (int) D.23364;
        D.23366 = __s2 + 1;
        D.23367 = *D.23366;
        D.23368 = (int) D.23367;
        __result = D.23365 - D.23368;
        if (__s2_len > 1) goto <D.23369>; else goto <D.23370>;
        <D.23369>:
        if (__result == 0) goto <D.23371>; else goto <D.23372>;
        <D.23371>:
        D.23373 = &MEM[(void *)".text" + 2B];
        D.23374 = *D.23373;
        D.23375 = (int) D.23374;
        D.23376 = __s2 + 2;
        D.23377 = *D.23376;
        D.23378 = (int) D.23377;
        __result = D.23375 - D.23378;
        if (__s2_len > 2) goto <D.23379>; else goto <D.23380>;
        <D.23379>:
        if (__result == 0) goto <D.23381>; else goto <D.23382>;
        <D.23381>:
        D.23383 = &MEM[(void *)".text" + 3B];
        D.23384 = *D.23383;
        D.23385 = (int) D.23384;
        D.23386 = __s2 + 3;
        D.23387 = *D.23386;
        D.23388 = (int) D.23387;
        __result = D.23385 - D.23388;
        <D.23382>:
        <D.23380>:
        <D.23372>:
        <D.23370>:
        <D.23362>:
        <D.23360>:
      }
      D.23125 = __result;
    }
    iftmp.0 = -D.23125;
    goto <D.23389>;
    <D.23353>:
    iftmp.0 = __builtin_strcmp (section_name, ".text");
    <D.23389>:
    D.23126 = iftmp.0;
  }
  if (D.23126 == 0) goto <D.23348>; else goto <D.23390>;
  <D.23390>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.23392>; else goto <D.23393>;
    <D.23392>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = section_name;
      D.23394 = ".data";
      D.23395 = MEM[(const unsigned char *)D.23394];
      D.23396 = (int) D.23395;
      D.23397 = *__s2;
      D.23398 = (int) D.23397;
      __result = D.23396 - D.23398;
      {
        if (__s2_len != 0) goto <D.23399>; else goto <D.23400>;
        <D.23399>:
        if (__result == 0) goto <D.23401>; else goto <D.23402>;
        <D.23401>:
        D.23403 = &MEM[(void *)".data" + 1B];
        D.23404 = *D.23403;
        D.23405 = (int) D.23404;
        D.23406 = __s2 + 1;
        D.23407 = *D.23406;
        D.23408 = (int) D.23407;
        __result = D.23405 - D.23408;
        if (__s2_len > 1) goto <D.23409>; else goto <D.23410>;
        <D.23409>:
        if (__result == 0) goto <D.23411>; else goto <D.23412>;
        <D.23411>:
        D.23413 = &MEM[(void *)".data" + 2B];
        D.23414 = *D.23413;
        D.23415 = (int) D.23414;
        D.23416 = __s2 + 2;
        D.23417 = *D.23416;
        D.23418 = (int) D.23417;
        __result = D.23415 - D.23418;
        if (__s2_len > 2) goto <D.23419>; else goto <D.23420>;
        <D.23419>:
        if (__result == 0) goto <D.23421>; else goto <D.23422>;
        <D.23421>:
        D.23423 = &MEM[(void *)".data" + 3B];
        D.23424 = *D.23423;
        D.23425 = (int) D.23424;
        D.23426 = __s2 + 3;
        D.23427 = *D.23426;
        D.23428 = (int) D.23427;
        __result = D.23425 - D.23428;
        <D.23422>:
        <D.23420>:
        <D.23412>:
        <D.23410>:
        <D.23402>:
        <D.23400>:
      }
      D.23134 = __result;
    }
    iftmp.1 = -D.23134;
    goto <D.23429>;
    <D.23393>:
    iftmp.1 = __builtin_strcmp (section_name, ".data");
    <D.23429>:
    D.23135 = iftmp.1;
  }
  if (D.23135 == 0) goto <D.23348>; else goto <D.23349>;
  <D.23348>:
  D.23430 = acfg->fp;
  fprintf (D.23430, "%s %d\n", section_name, subsection_index);
  goto <D.23350>;
  <D.23349>:
  D.23430 = acfg->fp;
  fprintf (D.23430, ".section \"%s\"\n", section_name);
  D.23430 = acfg->fp;
  fprintf (D.23430, ".subsection %d\n", subsection_index);
  <D.23350>:
}


asm_writer_emit_unset_mode (struct MonoImageWriter * acfg)
{
  int D.23431;
  struct FILE * D.23434;

  D.23431 = acfg->mode;
  if (D.23431 == 0) goto <D.23432>; else goto <D.23433>;
  <D.23432>:
  return;
  <D.23433>:
  D.23434 = acfg->fp;
  fprintf (D.23434, "\n");
  acfg->mode = 0;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.23436;

  D.23436 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.23436;
}


img_writer_emit_push_section (struct MonoImageWriter * acfg, const char * section_name, int subsection)
{
  int D.23438;
  _Bool D.23439;
  long int D.23440;
  long int D.23441;
  const char * D.23444;
  int D.23445;
  int D.23446;

  D.23438 = acfg->stack_pos;
  D.23439 = D.23438 > 14;
  D.23440 = (long int) D.23439;
  D.23441 = __builtin_expect (D.23440, 0);
  if (D.23441 != 0) goto <D.23442>; else goto <D.23443>;
  <D.23442>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2018, "acfg->stack_pos < 16 - 1");
  <D.23443>:
  D.23438 = acfg->stack_pos;
  D.23444 = acfg->current_section;
  acfg->section_stack[D.23438] = D.23444;
  D.23438 = acfg->stack_pos;
  D.23445 = acfg->current_subsection;
  acfg->subsection_stack[D.23438] = D.23445;
  D.23438 = acfg->stack_pos;
  D.23446 = D.23438 + 1;
  acfg->stack_pos = D.23446;
  img_writer_emit_section_change (acfg, section_name, subsection);
}


img_writer_emit_pop_section (struct MonoImageWriter * acfg)
{
  int D.23447;
  _Bool D.23448;
  long int D.23449;
  long int D.23450;
  int D.23453;
  const char * D.23454;
  int D.23455;

  D.23447 = acfg->stack_pos;
  D.23448 = D.23447 <= 0;
  D.23449 = (long int) D.23448;
  D.23450 = __builtin_expect (D.23449, 0);
  if (D.23450 != 0) goto <D.23451>; else goto <D.23452>;
  <D.23451>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2029, "acfg->stack_pos > 0");
  <D.23452>:
  D.23447 = acfg->stack_pos;
  D.23453 = D.23447 + -1;
  acfg->stack_pos = D.23453;
  D.23447 = acfg->stack_pos;
  D.23454 = acfg->section_stack[D.23447];
  D.23447 = acfg->stack_pos;
  D.23455 = acfg->subsection_stack[D.23447];
  img_writer_emit_section_change (acfg, D.23454, D.23455);
}


img_writer_set_section_addr (struct MonoImageWriter * acfg, guint64 addr)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "image-writer.c", 2043);
}


img_writer_emit_global (struct MonoImageWriter * acfg, const char * name, gboolean func)
{
  asm_writer_emit_global (acfg, name, func);
}


asm_writer_emit_global (struct MonoImageWriter * acfg, const char * name, gboolean func)
{
  struct FILE * D.23456;

  asm_writer_emit_unset_mode (acfg);
  D.23456 = acfg->fp;
  fprintf (D.23456, "\t.globl %s\n", name);
  asm_writer_emit_symbol_type (acfg, name, func);
}


asm_writer_emit_symbol_type (struct MonoImageWriter * acfg, const char * name, gboolean func)
{
  struct FILE * D.23460;
  const char * stype;

  if (func != 0) goto <D.23457>; else goto <D.23458>;
  <D.23457>:
  stype = "function";
  goto <D.23459>;
  <D.23458>:
  stype = "object";
  <D.23459>:
  asm_writer_emit_unset_mode (acfg);
  D.23460 = acfg->fp;
  fprintf (D.23460, "\t.type %s,@%s\n", name, stype);
}


img_writer_emit_local_symbol (struct MonoImageWriter * acfg, const char * name, const char * end_label, gboolean func)
{
  asm_writer_emit_local_symbol (acfg, name, end_label, func);
}


asm_writer_emit_local_symbol (struct MonoImageWriter * acfg, const char * name, const char * end_label, gboolean func)
{
  struct FILE * D.23461;

  asm_writer_emit_unset_mode (acfg);
  D.23461 = acfg->fp;
  fprintf (D.23461, "\t.local %s\n", name);
  asm_writer_emit_symbol_type (acfg, name, func);
}


img_writer_emit_symbol_size (struct MonoImageWriter * acfg, const char * name, const char * end_label)
{
  int D.23462;

  D.23462 = acfg->use_bin_writer;
  if (D.23462 == 0) goto <D.23463>; else goto <D.23464>;
  <D.23463>:
  asm_writer_emit_symbol_size (acfg, name, end_label);
  <D.23464>:
}


asm_writer_emit_symbol_size (struct MonoImageWriter * acfg, const char * name, const char * end_label)
{
  struct FILE * D.23465;

  asm_writer_emit_unset_mode (acfg);
  D.23465 = acfg->fp;
  fprintf (D.23465, "\t.size %s,%s-%s\n", name, end_label, name);
}


img_writer_emit_label (struct MonoImageWriter * acfg, const char * name)
{
  asm_writer_emit_label (acfg, name);
}


asm_writer_emit_label (struct MonoImageWriter * acfg, const char * name)
{
  struct FILE * D.23466;
  const char * D.23467;

  asm_writer_emit_unset_mode (acfg);
  D.23466 = acfg->fp;
  D.23467 = get_label (name);
  fprintf (D.23466, "%s:\n", D.23467);
}


get_label (const char * s)
{
  const char * D.23468;

  D.23468 = s;
  return D.23468;
}


img_writer_emit_bytes (struct MonoImageWriter * acfg, const guint8 * buf, int size)
{
  asm_writer_emit_bytes (acfg, buf, size);
}


asm_writer_emit_bytes (struct MonoImageWriter * acfg, const guint8 * buf, int size)
{
  int D.23470;
  char * byte_to_str.2;
  void * byte_to_str.3;
  int D.23477;
  sizetype D.23478;
  char * D.23479;
  int D.23480;
  unsigned int D.23481;
  unsigned int D.23482;
  struct FILE * D.23485;
  sizetype D.23486;
  const guint8 * D.23487;
  unsigned char D.23488;
  int D.23489;
  int D.23491;
  sizetype D.23492;
  char * D.23493;
  int D.23494;
  int i;

  D.23470 = acfg->mode;
  if (D.23470 != 1) goto <D.23471>; else goto <D.23472>;
  <D.23471>:
  acfg->mode = 1;
  acfg->col_count = 0;
  <D.23472>:
  byte_to_str.2 = byte_to_str;
  if (byte_to_str.2 == 0B) goto <D.23474>; else goto <D.23475>;
  <D.23474>:
  byte_to_str.3 = monoeg_malloc0 (2048);
  byte_to_str = byte_to_str.3;
  i = 0;
  goto <D.23192>;
  <D.23191>:
  byte_to_str.2 = byte_to_str;
  D.23477 = i * 8;
  D.23478 = (sizetype) D.23477;
  D.23479 = byte_to_str.2 + D.23478;
  sprintf (D.23479, ",%d", i);
  i = i + 1;
  <D.23192>:
  if (i <= 255) goto <D.23191>; else goto <D.23193>;
  <D.23193>:
  <D.23475>:
  i = 0;
  goto <D.23195>;
  <D.23194>:
  D.23480 = acfg->col_count;
  D.23481 = (unsigned int) D.23480;
  D.23482 = D.23481 & 31;
  if (D.23482 == 0) goto <D.23483>; else goto <D.23484>;
  <D.23483>:
  D.23485 = acfg->fp;
  D.23486 = (sizetype) i;
  D.23487 = buf + D.23486;
  D.23488 = *D.23487;
  D.23489 = (int) D.23488;
  fprintf (D.23485, "\n\t.byte %d", D.23489);
  goto <D.23490>;
  <D.23484>:
  byte_to_str.2 = byte_to_str;
  D.23486 = (sizetype) i;
  D.23487 = buf + D.23486;
  D.23488 = *D.23487;
  D.23489 = (int) D.23488;
  D.23491 = D.23489 * 8;
  D.23492 = (sizetype) D.23491;
  D.23493 = byte_to_str.2 + D.23492;
  D.23485 = acfg->fp;
  fputs (D.23493, D.23485);
  <D.23490>:
  i = i + 1;
  D.23480 = acfg->col_count;
  D.23494 = D.23480 + 1;
  acfg->col_count = D.23494;
  <D.23195>:
  if (i < size) goto <D.23194>; else goto <D.23196>;
  <D.23196>:
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.23495;
  long unsigned int D.23496;

  D.23496 = __builtin_object_size (__s, 1);
  D.23495 = __builtin___sprintf_chk (__s, 1, D.23496, __fmt, __builtin_va_arg_pack ());
  return D.23495;
}


img_writer_emit_string (struct MonoImageWriter * acfg, const char * value)
{
  asm_writer_emit_string (acfg, value);
}


asm_writer_emit_string (struct MonoImageWriter * acfg, const char * value)
{
  struct FILE * D.23498;

  asm_writer_emit_unset_mode (acfg);
  D.23498 = acfg->fp;
  fprintf (D.23498, "\t%s \"%s\"\n", ".asciz", value);
}


img_writer_emit_line (struct MonoImageWriter * acfg)
{
  asm_writer_emit_line (acfg);
}


asm_writer_emit_line (struct MonoImageWriter * acfg)
{
  struct FILE * D.23499;

  asm_writer_emit_unset_mode (acfg);
  D.23499 = acfg->fp;
  fprintf (D.23499, "\n");
}


img_writer_emit_alignment (struct MonoImageWriter * acfg, int size)
{
  asm_writer_emit_alignment (acfg, size);
}


asm_writer_emit_alignment (struct MonoImageWriter * acfg, int size)
{
  struct FILE * D.23500;

  asm_writer_emit_unset_mode (acfg);
  D.23500 = acfg->fp;
  fprintf (D.23500, "\t.balign %d\n", size);
}


img_writer_emit_pointer_unaligned (struct MonoImageWriter * acfg, const char * target)
{
  asm_writer_emit_pointer_unaligned (acfg, target);
}


asm_writer_emit_pointer_unaligned (struct MonoImageWriter * acfg, const char * target)
{
  struct FILE * D.23501;
  const char * iftmp.4;

  asm_writer_emit_unset_mode (acfg);
  D.23501 = acfg->fp;
  if (target != 0B) goto <D.23503>; else goto <D.23504>;
  <D.23503>:
  iftmp.4 = target;
  goto <D.23505>;
  <D.23504>:
  iftmp.4 = "0";
  <D.23505>:
  fprintf (D.23501, "\t%s %s\n", ".quad", iftmp.4);
}


img_writer_emit_pointer (struct MonoImageWriter * acfg, const char * target)
{
  asm_writer_emit_pointer (acfg, target);
}


asm_writer_emit_pointer (struct MonoImageWriter * acfg, const char * target)
{
  asm_writer_emit_unset_mode (acfg);
  asm_writer_emit_alignment (acfg, 8);
  asm_writer_emit_pointer_unaligned (acfg, target);
}


img_writer_emit_int16 (struct MonoImageWriter * acfg, int value)
{
  asm_writer_emit_int16 (acfg, value);
}


asm_writer_emit_int16 (struct MonoImageWriter * acfg, int value)
{
  int D.23506;
  int D.23509;
  int D.23510;
  int D.23511;
  unsigned int D.23512;
  unsigned int D.23513;
  struct FILE * D.23516;

  D.23506 = acfg->mode;
  if (D.23506 != 2) goto <D.23507>; else goto <D.23508>;
  <D.23507>:
  acfg->mode = 2;
  acfg->col_count = 0;
  <D.23508>:
  D.23509 = acfg->col_count;
  D.23510 = D.23509;
  D.23511 = D.23510 + 1;
  acfg->col_count = D.23511;
  D.23512 = (unsigned int) D.23510;
  D.23513 = D.23512 & 7;
  if (D.23513 == 0) goto <D.23514>; else goto <D.23515>;
  <D.23514>:
  D.23516 = acfg->fp;
  fprintf (D.23516, "\n\t%s ", ".hword");
  goto <D.23517>;
  <D.23515>:
  D.23516 = acfg->fp;
  fprintf (D.23516, ", ");
  <D.23517>:
  D.23516 = acfg->fp;
  fprintf (D.23516, "%d", value);
}


img_writer_emit_int32 (struct MonoImageWriter * acfg, int value)
{
  asm_writer_emit_int32 (acfg, value);
}


asm_writer_emit_int32 (struct MonoImageWriter * acfg, int value)
{
  int D.23518;
  int D.23521;
  int D.23522;
  int D.23523;
  unsigned int D.23524;
  unsigned int D.23525;
  struct FILE * D.23528;

  D.23518 = acfg->mode;
  if (D.23518 != 3) goto <D.23519>; else goto <D.23520>;
  <D.23519>:
  acfg->mode = 3;
  acfg->col_count = 0;
  <D.23520>:
  D.23521 = acfg->col_count;
  D.23522 = D.23521;
  D.23523 = D.23522 + 1;
  acfg->col_count = D.23523;
  D.23524 = (unsigned int) D.23522;
  D.23525 = D.23524 & 7;
  if (D.23525 == 0) goto <D.23526>; else goto <D.23527>;
  <D.23526>:
  D.23528 = acfg->fp;
  fprintf (D.23528, "\n\t%s ", ".long");
  goto <D.23529>;
  <D.23527>:
  D.23528 = acfg->fp;
  fprintf (D.23528, ",");
  <D.23529>:
  D.23528 = acfg->fp;
  fprintf (D.23528, "%d", value);
}


img_writer_emit_symbol_diff (struct MonoImageWriter * acfg, const char * end, const char * start, int offset)
{
  asm_writer_emit_symbol_diff (acfg, end, start, offset);
}


asm_writer_emit_symbol_diff (struct MonoImageWriter * acfg, const char * end, const char * start, int offset)
{
  int D.23530;
  int D.23219;
  int iftmp.5;
  int D.23218;
  const char[2] * D.23538;
  unsigned char D.23539;
  int D.23540;
  unsigned char D.23541;
  int D.23542;
  const unsigned char * D.23547;
  unsigned char D.23548;
  int D.23549;
  const unsigned char * D.23550;
  unsigned char D.23551;
  int D.23552;
  const unsigned char * D.23557;
  unsigned char D.23558;
  int D.23559;
  const unsigned char * D.23560;
  unsigned char D.23561;
  int D.23562;
  const unsigned char * D.23567;
  unsigned char D.23568;
  int D.23569;
  const unsigned char * D.23570;
  unsigned char D.23571;
  int D.23572;
  int D.23576;
  int D.23577;
  struct FILE * D.23578;
  int D.23579;
  int D.23580;
  int D.23581;
  unsigned int D.23582;
  unsigned int D.23583;

  D.23530 = acfg->mode;
  if (D.23530 != 3) goto <D.23531>; else goto <D.23532>;
  <D.23531>:
  acfg->mode = 3;
  acfg->col_count = 0;
  <D.23532>:
  start = get_label (start);
  end = get_label (end);
  if (offset == 0) goto <D.23533>; else goto <D.23534>;
  <D.23533>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.23536>; else goto <D.23537>;
    <D.23536>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = start;
      D.23538 = ".";
      D.23539 = MEM[(const unsigned char *)D.23538];
      D.23540 = (int) D.23539;
      D.23541 = *__s2;
      D.23542 = (int) D.23541;
      __result = D.23540 - D.23542;
      {
        if (__s2_len != 0) goto <D.23543>; else goto <D.23544>;
        <D.23543>:
        if (__result == 0) goto <D.23545>; else goto <D.23546>;
        <D.23545>:
        D.23547 = &MEM[(void *)"." + 1B];
        D.23548 = *D.23547;
        D.23549 = (int) D.23548;
        D.23550 = __s2 + 1;
        D.23551 = *D.23550;
        D.23552 = (int) D.23551;
        __result = D.23549 - D.23552;
        if (__s2_len > 1) goto <D.23553>; else goto <D.23554>;
        <D.23553>:
        if (__result == 0) goto <D.23555>; else goto <D.23556>;
        <D.23555>:
        D.23557 = &MEM[(void *)"." + 2B];
        D.23558 = *D.23557;
        D.23559 = (int) D.23558;
        D.23560 = __s2 + 2;
        D.23561 = *D.23560;
        D.23562 = (int) D.23561;
        __result = D.23559 - D.23562;
        if (__s2_len > 2) goto <D.23563>; else goto <D.23564>;
        <D.23563>:
        if (__result == 0) goto <D.23565>; else goto <D.23566>;
        <D.23565>:
        D.23567 = &MEM[(void *)"." + 3B];
        D.23568 = *D.23567;
        D.23569 = (int) D.23568;
        D.23570 = __s2 + 3;
        D.23571 = *D.23570;
        D.23572 = (int) D.23571;
        __result = D.23569 - D.23572;
        <D.23566>:
        <D.23564>:
        <D.23556>:
        <D.23554>:
        <D.23546>:
        <D.23544>:
      }
      D.23218 = __result;
    }
    iftmp.5 = -D.23218;
    goto <D.23573>;
    <D.23537>:
    iftmp.5 = __builtin_strcmp (start, ".");
    <D.23573>:
    D.23219 = iftmp.5;
  }
  if (D.23219 != 0) goto <D.23574>; else goto <D.23575>;
  <D.23574>:
  {
    char symbol[128];

    try
      {
        D.23576 = acfg->label_gen;
        sprintf (&symbol, "%sDIFF_SYM%d", ".L", D.23576);
        D.23576 = acfg->label_gen;
        D.23577 = D.23576 + 1;
        acfg->label_gen = D.23577;
        D.23578 = acfg->fp;
        fprintf (D.23578, "\n%s=%s - %s", &symbol, end, start);
        D.23578 = acfg->fp;
        fprintf (D.23578, "\n\t%s ", ".long");
        D.23578 = acfg->fp;
        fprintf (D.23578, "%s", &symbol);
        return;
      }
    finally
      {
        symbol = {CLOBBER};
      }
  }
  <D.23575>:
  <D.23534>:
  D.23579 = acfg->col_count;
  D.23580 = D.23579;
  D.23581 = D.23580 + 1;
  acfg->col_count = D.23581;
  D.23582 = (unsigned int) D.23580;
  D.23583 = D.23582 & 7;
  if (D.23583 == 0) goto <D.23584>; else goto <D.23585>;
  <D.23584>:
  D.23578 = acfg->fp;
  fprintf (D.23578, "\n\t%s ", ".long");
  goto <D.23586>;
  <D.23585>:
  D.23578 = acfg->fp;
  fprintf (D.23578, ",");
  <D.23586>:
  if (offset > 0) goto <D.23587>; else goto <D.23588>;
  <D.23587>:
  D.23578 = acfg->fp;
  fprintf (D.23578, "%s - %s + %d", end, start, offset);
  goto <D.23589>;
  <D.23588>:
  if (offset < 0) goto <D.23590>; else goto <D.23591>;
  <D.23590>:
  D.23578 = acfg->fp;
  fprintf (D.23578, "%s - %s %d", end, start, offset);
  goto <D.23592>;
  <D.23591>:
  D.23578 = acfg->fp;
  fprintf (D.23578, "%s - %s", end, start);
  <D.23592>:
  <D.23589>:
}


img_writer_emit_zero_bytes (struct MonoImageWriter * acfg, int num)
{
  asm_writer_emit_zero_bytes (acfg, num);
}


asm_writer_emit_zero_bytes (struct MonoImageWriter * acfg, int num)
{
  struct FILE * D.23595;

  asm_writer_emit_unset_mode (acfg);
  D.23595 = acfg->fp;
  fprintf (D.23595, "\t%s %d\n", ".skip", num);
}


img_writer_emit_writeout (struct MonoImageWriter * acfg)
{
  int D.23596;

  D.23596 = asm_writer_emit_writeout (acfg);
  return D.23596;
}


asm_writer_emit_writeout (struct MonoImageWriter * acfg)
{
  struct FILE * D.23598;
  int D.23599;

  D.23598 = acfg->fp;
  fclose (D.23598);
  D.23599 = 0;
  return D.23599;
}


img_writer_emit_byte (struct MonoImageWriter * acfg, guint8 val)
{
  img_writer_emit_bytes (acfg, &val, 1);
}


img_writer_emit_reloc (struct MonoImageWriter * acfg, int reloc_type, const char * symbol, int addend)
{
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "image-writer.c", 2270);
}


img_writer_emit_unset_mode (struct MonoImageWriter * acfg)
{
  int D.23601;

  D.23601 = acfg->use_bin_writer;
  if (D.23601 == 0) goto <D.23602>; else goto <D.23603>;
  <D.23602>:
  asm_writer_emit_unset_mode (acfg);
  <D.23603>:
}


img_writer_get_output (struct MonoImageWriter * acfg, guint32 * size)
{
  guint8 * D.23604;

  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "image-writer.c", 2306);
  D.23604 = 0B;
  return D.23604;
}


bin_writer_supported ()
{
  gboolean D.23606;

  D.23606 = 0;
  return D.23606;
}


img_writer_create (struct FILE * fp, gboolean use_bin_writer)
{
  _Bool D.23608;
  long int D.23609;
  long int D.23610;
  _Bool D.23615;
  long int D.23616;
  long int D.23617;
  struct MonoMemPool * D.23620;
  struct MonoImageWriter * D.23621;
  struct MonoImageWriter * w;

  w = monoeg_malloc0 (272);
  D.23608 = use_bin_writer != 0;
  D.23609 = (long int) D.23608;
  D.23610 = __builtin_expect (D.23609, 0);
  if (D.23610 != 0) goto <D.23611>; else goto <D.23612>;
  <D.23611>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2337, "!use_bin_writer");
  <D.23612>:
  if (use_bin_writer == 0) goto <D.23613>; else goto <D.23614>;
  <D.23613>:
  D.23615 = fp == 0B;
  D.23616 = (long int) D.23615;
  D.23617 = __builtin_expect (D.23616, 0);
  if (D.23617 != 0) goto <D.23618>; else goto <D.23619>;
  <D.23618>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2341, "fp");
  <D.23619>:
  <D.23614>:
  w->fp = fp;
  w->use_bin_writer = use_bin_writer;
  D.23620 = mono_mempool_new ();
  w->mempool = D.23620;
  D.23621 = w;
  return D.23621;
}


img_writer_destroy (struct MonoImageWriter * w)
{
  struct MonoMemPool * D.23623;

  D.23623 = w->mempool;
  mono_mempool_destroy (D.23623);
  monoeg_g_free (w);
}


img_writer_subsections_supported (struct MonoImageWriter * acfg)
{
  gboolean D.23624;

  D.23624 = 1;
  return D.23624;
}


img_writer_get_fp (struct MonoImageWriter * acfg)
{
  struct FILE * D.23626;

  D.23626 = acfg->fp;
  return D.23626;
}


img_writer_get_temp_label_prefix (struct MonoImageWriter * acfg)
{
  const char * D.23628;

  D.23628 = ".L";
  return D.23628;
}