__attribute__((visibility ("hidden")))
img_writer_emit_start (struct MonoImageWriter * acfg)
{
  asm_writer_emit_start (acfg);
}


asm_writer_emit_start (struct MonoImageWriter * acfg)
{

}


__attribute__((visibility ("hidden")))
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.23150;
  int D.23152;
  int D.23154;
  struct FILE * D.23155;

  asm_writer_emit_unset_mode (acfg);
  D.23150 = strcmp (section_name, ".text");
  if (D.23150 == 0) goto <D.23147>; else goto <D.23151>;
  <D.23151>:
  D.23152 = strcmp (section_name, ".data");
  if (D.23152 == 0) goto <D.23147>; else goto <D.23153>;
  <D.23153>:
  D.23154 = strcmp (section_name, ".bss");
  if (D.23154 == 0) goto <D.23147>; else goto <D.23148>;
  <D.23147>:
  D.23155 = acfg->fp;
  fprintf (D.23155, "%s %d\n", section_name, subsection_index);
  goto <D.23149>;
  <D.23148>:
  D.23155 = acfg->fp;
  fprintf (D.23155, ".section \"%s\"\n", section_name);
  D.23155 = acfg->fp;
  fprintf (D.23155, ".subsection %d\n", subsection_index);
  <D.23149>:
}


asm_writer_emit_unset_mode (struct MonoImageWriter * acfg)
{
  int D.23156;
  struct FILE * D.23159;

  D.23156 = acfg->mode;
  if (D.23156 == 0) goto <D.23157>; else goto <D.23158>;
  <D.23157>:
  return;
  <D.23158>:
  D.23159 = acfg->fp;
  fprintf (D.23159, "\n");
  acfg->mode = 0;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.0;
  int iftmp.1;
  int D.23169;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.23162>; else goto <D.23163>;
  <D.23162>:
  if (__ret == 1) goto <D.23165>; else goto <D.23166>;
  <D.23165>:
  iftmp.1 = -1;
  goto <D.23167>;
  <D.23166>:
  iftmp.1 = 1;
  <D.23167>:
  iftmp.0 = iftmp.1;
  goto <D.23168>;
  <D.23163>:
  iftmp.0 = 0;
  <D.23168>:
  __ret = iftmp.0;
  D.23169 = __ret;
  return D.23169;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.23171;

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


__attribute__((visibility ("hidden")))
img_writer_emit_push_section (struct MonoImageWriter * acfg, const char * section_name, int subsection)
{
  int D.23173;
  _Bool D.23174;
  long int D.23175;
  long int D.23176;
  const char * D.23179;
  int D.23180;
  int D.23181;

  D.23173 = acfg->stack_pos;
  D.23174 = D.23173 > 14;
  D.23175 = (long int) D.23174;
  D.23176 = __builtin_expect (D.23175, 0);
  if (D.23176 != 0) goto <D.23177>; else goto <D.23178>;
  <D.23177>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2018, "acfg->stack_pos < 16 - 1");
  <D.23178>:
  D.23173 = acfg->stack_pos;
  D.23179 = acfg->current_section;
  acfg->section_stack[D.23173] = D.23179;
  D.23173 = acfg->stack_pos;
  D.23180 = acfg->current_subsection;
  acfg->subsection_stack[D.23173] = D.23180;
  D.23173 = acfg->stack_pos;
  D.23181 = D.23173 + 1;
  acfg->stack_pos = D.23181;
  img_writer_emit_section_change (acfg, section_name, subsection);
}


__attribute__((visibility ("hidden")))
img_writer_emit_pop_section (struct MonoImageWriter * acfg)
{
  int D.23182;
  _Bool D.23183;
  long int D.23184;
  long int D.23185;
  int D.23188;
  const char * D.23189;
  int D.23190;

  D.23182 = acfg->stack_pos;
  D.23183 = D.23182 <= 0;
  D.23184 = (long int) D.23183;
  D.23185 = __builtin_expect (D.23184, 0);
  if (D.23185 != 0) goto <D.23186>; else goto <D.23187>;
  <D.23186>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2029, "acfg->stack_pos > 0");
  <D.23187>:
  D.23182 = acfg->stack_pos;
  D.23188 = D.23182 + -1;
  acfg->stack_pos = D.23188;
  D.23182 = acfg->stack_pos;
  D.23189 = acfg->section_stack[D.23182];
  D.23182 = acfg->stack_pos;
  D.23190 = acfg->subsection_stack[D.23182];
  img_writer_emit_section_change (acfg, D.23189, D.23190);
}


__attribute__((visibility ("hidden")))
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);
}


__attribute__((visibility ("hidden")))
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.23191;

  asm_writer_emit_unset_mode (acfg);
  D.23191 = acfg->fp;
  fprintf (D.23191, "\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.23195;
  const char * stype;

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


__attribute__((visibility ("hidden")))
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.23196;

  asm_writer_emit_unset_mode (acfg);
  D.23196 = acfg->fp;
  fprintf (D.23196, "\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.23197;

  D.23197 = acfg->use_bin_writer;
  if (D.23197 == 0) goto <D.23198>; else goto <D.23199>;
  <D.23198>:
  asm_writer_emit_symbol_size (acfg, name, end_label);
  <D.23199>:
}


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

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


__attribute__((visibility ("hidden")))
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.23201;
  const char * D.23202;

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


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

  D.23203 = s;
  return D.23203;
}


__attribute__((visibility ("hidden")))
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.23205;
  char * byte_to_str.2;
  void * D.23211;
  int D.23212;
  sizetype D.23213;
  char * D.23214;
  int D.23215;
  unsigned int D.23216;
  unsigned int D.23217;
  struct FILE * D.23220;
  sizetype D.23221;
  const guint8 * D.23222;
  unsigned char D.23223;
  int D.23224;
  int D.23226;
  sizetype D.23227;
  char * D.23228;
  int D.23229;
  int i;

  D.23205 = acfg->mode;
  if (D.23205 != 1) goto <D.23206>; else goto <D.23207>;
  <D.23206>:
  acfg->mode = 1;
  acfg->col_count = 0;
  <D.23207>:
  byte_to_str.2 = byte_to_str;
  if (byte_to_str.2 == 0B) goto <D.23209>; else goto <D.23210>;
  <D.23209>:
  D.23211 = monoeg_malloc0 (2048);
  byte_to_str = D.23211;
  i = 0;
  goto <D.23000>;
  <D.22999>:
  byte_to_str.2 = byte_to_str;
  D.23212 = i * 8;
  D.23213 = (sizetype) D.23212;
  D.23214 = byte_to_str.2 + D.23213;
  sprintf (D.23214, ",%d", i);
  i = i + 1;
  <D.23000>:
  if (i <= 255) goto <D.22999>; else goto <D.23001>;
  <D.23001>:
  <D.23210>:
  i = 0;
  goto <D.23003>;
  <D.23002>:
  D.23215 = acfg->col_count;
  D.23216 = (unsigned int) D.23215;
  D.23217 = D.23216 & 31;
  if (D.23217 == 0) goto <D.23218>; else goto <D.23219>;
  <D.23218>:
  D.23220 = acfg->fp;
  D.23221 = (sizetype) i;
  D.23222 = buf + D.23221;
  D.23223 = *D.23222;
  D.23224 = (int) D.23223;
  fprintf (D.23220, "\n\t.byte %d", D.23224);
  goto <D.23225>;
  <D.23219>:
  byte_to_str.2 = byte_to_str;
  D.23221 = (sizetype) i;
  D.23222 = buf + D.23221;
  D.23223 = *D.23222;
  D.23224 = (int) D.23223;
  D.23226 = D.23224 * 8;
  D.23227 = (sizetype) D.23226;
  D.23228 = byte_to_str.2 + D.23227;
  D.23220 = acfg->fp;
  fputs (D.23228, D.23220);
  <D.23225>:
  i = i + 1;
  D.23215 = acfg->col_count;
  D.23229 = D.23215 + 1;
  acfg->col_count = D.23229;
  <D.23003>:
  if (i < size) goto <D.23002>; else goto <D.23004>;
  <D.23004>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.23230;
  long unsigned int D.23231;

  D.23231 = __builtin_object_size (__s, 1);
  D.23230 = __builtin___sprintf_chk (__s, 1, D.23231, __fmt, __builtin_va_arg_pack ());
  return D.23230;
}


__attribute__((visibility ("hidden")))
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.23233;

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


__attribute__((visibility ("hidden")))
img_writer_emit_line (struct MonoImageWriter * acfg)
{
  asm_writer_emit_line (acfg);
}


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

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


__attribute__((visibility ("hidden")))
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.23235;

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


__attribute__((visibility ("hidden")))
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.23236;
  const char * iftmp.3;

  asm_writer_emit_unset_mode (acfg);
  D.23236 = acfg->fp;
  if (target != 0B) goto <D.23238>; else goto <D.23239>;
  <D.23238>:
  iftmp.3 = target;
  goto <D.23240>;
  <D.23239>:
  iftmp.3 = "0";
  <D.23240>:
  fprintf (D.23236, "\t%s %s\n", ".long", iftmp.3);
}


__attribute__((visibility ("hidden")))
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);
}


__attribute__((visibility ("hidden")))
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.23241;
  int D.23244;
  int D.23245;
  int D.23246;
  unsigned int D.23247;
  unsigned int D.23248;
  struct FILE * D.23251;

  D.23241 = acfg->mode;
  if (D.23241 != 2) goto <D.23242>; else goto <D.23243>;
  <D.23242>:
  acfg->mode = 2;
  acfg->col_count = 0;
  <D.23243>:
  D.23244 = acfg->col_count;
  D.23245 = D.23244;
  D.23246 = D.23245 + 1;
  acfg->col_count = D.23246;
  D.23247 = (unsigned int) D.23245;
  D.23248 = D.23247 & 7;
  if (D.23248 == 0) goto <D.23249>; else goto <D.23250>;
  <D.23249>:
  D.23251 = acfg->fp;
  fprintf (D.23251, "\n\t%s ", ".hword");
  goto <D.23252>;
  <D.23250>:
  D.23251 = acfg->fp;
  fprintf (D.23251, ", ");
  <D.23252>:
  D.23251 = acfg->fp;
  fprintf (D.23251, "%d", value);
}


__attribute__((visibility ("hidden")))
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.23253;
  int D.23256;
  int D.23257;
  int D.23258;
  unsigned int D.23259;
  unsigned int D.23260;
  struct FILE * D.23263;

  D.23253 = acfg->mode;
  if (D.23253 != 3) goto <D.23254>; else goto <D.23255>;
  <D.23254>:
  acfg->mode = 3;
  acfg->col_count = 0;
  <D.23255>:
  D.23256 = acfg->col_count;
  D.23257 = D.23256;
  D.23258 = D.23257 + 1;
  acfg->col_count = D.23258;
  D.23259 = (unsigned int) D.23257;
  D.23260 = D.23259 & 7;
  if (D.23260 == 0) goto <D.23261>; else goto <D.23262>;
  <D.23261>:
  D.23263 = acfg->fp;
  fprintf (D.23263, "\n\t%s ", ".long");
  goto <D.23264>;
  <D.23262>:
  D.23263 = acfg->fp;
  fprintf (D.23263, ",");
  <D.23264>:
  D.23263 = acfg->fp;
  fprintf (D.23263, "%d", value);
}


__attribute__((visibility ("hidden")))
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.23265;
  int D.23270;
  int D.23273;
  int D.23274;
  struct FILE * D.23275;
  int D.23276;
  int D.23277;
  int D.23278;
  unsigned int D.23279;
  unsigned int D.23280;

  D.23265 = acfg->mode;
  if (D.23265 != 3) goto <D.23266>; else goto <D.23267>;
  <D.23266>:
  acfg->mode = 3;
  acfg->col_count = 0;
  <D.23267>:
  start = get_label (start);
  end = get_label (end);
  if (offset == 0) goto <D.23268>; else goto <D.23269>;
  <D.23268>:
  D.23270 = strcmp (start, ".");
  if (D.23270 != 0) goto <D.23271>; else goto <D.23272>;
  <D.23271>:
  {
    char symbol[128];

    try
      {
        D.23273 = acfg->label_gen;
        sprintf (&symbol, "%sDIFF_SYM%d", ".L", D.23273);
        D.23273 = acfg->label_gen;
        D.23274 = D.23273 + 1;
        acfg->label_gen = D.23274;
        D.23275 = acfg->fp;
        fprintf (D.23275, "\n%s=%s - %s", &symbol, end, start);
        D.23275 = acfg->fp;
        fprintf (D.23275, "\n\t%s ", ".long");
        D.23275 = acfg->fp;
        fprintf (D.23275, "%s", &symbol);
        return;
      }
    finally
      {
        symbol = {CLOBBER};
      }
  }
  <D.23272>:
  <D.23269>:
  D.23276 = acfg->col_count;
  D.23277 = D.23276;
  D.23278 = D.23277 + 1;
  acfg->col_count = D.23278;
  D.23279 = (unsigned int) D.23277;
  D.23280 = D.23279 & 7;
  if (D.23280 == 0) goto <D.23281>; else goto <D.23282>;
  <D.23281>:
  D.23275 = acfg->fp;
  fprintf (D.23275, "\n\t%s ", ".long");
  goto <D.23283>;
  <D.23282>:
  D.23275 = acfg->fp;
  fprintf (D.23275, ",");
  <D.23283>:
  if (offset > 0) goto <D.23284>; else goto <D.23285>;
  <D.23284>:
  D.23275 = acfg->fp;
  fprintf (D.23275, "%s - %s + %d", end, start, offset);
  goto <D.23286>;
  <D.23285>:
  if (offset < 0) goto <D.23287>; else goto <D.23288>;
  <D.23287>:
  D.23275 = acfg->fp;
  fprintf (D.23275, "%s - %s %d", end, start, offset);
  goto <D.23289>;
  <D.23288>:
  D.23275 = acfg->fp;
  fprintf (D.23275, "%s - %s", end, start);
  <D.23289>:
  <D.23286>:
}


__attribute__((visibility ("hidden")))
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.23292;

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


__attribute__((visibility ("hidden")))
img_writer_emit_writeout (struct MonoImageWriter * acfg)
{
  int D.23293;

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


asm_writer_emit_writeout (struct MonoImageWriter * acfg)
{
  struct FILE * D.23295;
  int D.23296;

  D.23295 = acfg->fp;
  fclose (D.23295);
  D.23296 = 0;
  return D.23296;
}


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


__attribute__((visibility ("hidden")))
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);
}


__attribute__((visibility ("hidden")))
img_writer_emit_unset_mode (struct MonoImageWriter * acfg)
{
  int D.23298;

  D.23298 = acfg->use_bin_writer;
  if (D.23298 == 0) goto <D.23299>; else goto <D.23300>;
  <D.23299>:
  asm_writer_emit_unset_mode (acfg);
  <D.23300>:
}


__attribute__((visibility ("hidden")))
img_writer_get_output (struct MonoImageWriter * acfg, guint32 * size)
{
  guint8 * D.23301;

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


__attribute__((visibility ("hidden")))
bin_writer_supported ()
{
  gboolean D.23303;

  D.23303 = 0;
  return D.23303;
}


__attribute__((visibility ("hidden")))
img_writer_create (struct FILE * fp, gboolean use_bin_writer)
{
  _Bool D.23305;
  long int D.23306;
  long int D.23307;
  _Bool D.23312;
  long int D.23313;
  long int D.23314;
  struct MonoMemPool * D.23317;
  struct MonoImageWriter * D.23318;
  struct MonoImageWriter * w;

  w = monoeg_malloc0 (272);
  D.23305 = use_bin_writer != 0;
  D.23306 = (long int) D.23305;
  D.23307 = __builtin_expect (D.23306, 0);
  if (D.23307 != 0) goto <D.23308>; else goto <D.23309>;
  <D.23308>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2337, "!use_bin_writer");
  <D.23309>:
  if (use_bin_writer == 0) goto <D.23310>; else goto <D.23311>;
  <D.23310>:
  D.23312 = fp == 0B;
  D.23313 = (long int) D.23312;
  D.23314 = __builtin_expect (D.23313, 0);
  if (D.23314 != 0) goto <D.23315>; else goto <D.23316>;
  <D.23315>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "image-writer.c", 2341, "fp");
  <D.23316>:
  <D.23311>:
  w->fp = fp;
  w->use_bin_writer = use_bin_writer;
  D.23317 = mono_mempool_new ();
  w->mempool = D.23317;
  D.23318 = w;
  return D.23318;
}


__attribute__((visibility ("hidden")))
img_writer_destroy (struct MonoImageWriter * w)
{
  struct MonoMemPool * D.23320;

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


__attribute__((visibility ("hidden")))
img_writer_subsections_supported (struct MonoImageWriter * acfg)
{
  gboolean D.23321;

  D.23321 = 1;
  return D.23321;
}


__attribute__((visibility ("hidden")))
img_writer_get_fp (struct MonoImageWriter * acfg)
{
  struct FILE * D.23323;

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


__attribute__((visibility ("hidden")))
img_writer_get_temp_label_prefix (struct MonoImageWriter * acfg)
{
  const char * D.23325;

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