/* Generated automatically by the program `genoutput'
from the machine description file `md'.  */

#include "config.h"
#include "system.h"
#include "flags.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "real.h"
#include "insn-config.h"

#include "conditions.h"
#include "insn-flags.h"
#include "insn-attr.h"

#include "insn-codes.h"

#include "recog.h"

#include "output.h"

static const char *
output_0 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_0[] = {
    "addl %1,$31,%0",
    "ldl %0,%1",
    "lds %0,%1\n\tcvtlq %0,%0",
  };
  return strings_0[which_alternative];
}

static const char *
output_4 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_4[] = {
    "addl %r1,%2,%0",
    "subl %r1,%n2,%0",
    "lda %0,%2(%r1)",
    "ldah %0,%h2(%r1)",
  };
  return strings_4[which_alternative];
}

static const char *
output_6 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_6[] = {
    "addl %r1,%2,%0",
    "subl %r1,%n2,%0",
  };
  return strings_6[which_alternative];
}

static const char *
output_9 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{

{
  const char * const pattern[4] = {
    "addq %r1,%2,%0",
    "subq %r1,%n2,%0",
    "lda %0,%2(%r1)",
    "ldah %0,%h2(%r1)"
  };

  /* The NT stack unwind code can't handle a subq to adjust the stack
     (that's a bug, but not one we can do anything about).  As of NT4.0 SP3,
     the exception handling code will loop if a subq is used and an
     exception occurs.

     The 19980616 change to emit prologues as RTL also confused some
     versions of GDB, which also interprets prologues.  This has been
     fixed as of GDB 4.18, but it does not harm to unconditionally
     use lda here.  */

  int which = which_alternative;

  if (operands[0] == stack_pointer_rtx
      && GET_CODE (operands[2]) == CONST_INT
      && CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), 'K'))
    which = 2;

  return pattern[which];
}
}

static const char *
output_12 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_12[] = {
    "s%2addl %1,%3,%0",
    "s%2subl %1,%n3,%0",
  };
  return strings_12[which_alternative];
}

static const char *
output_13 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_13[] = {
    "s%2addl %1,%3,%0",
    "s%2subl %1,%n3,%0",
  };
  return strings_13[which_alternative];
}

static const char *
output_15 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_15[] = {
    "s%2addq %1,%3,%0",
    "s%2subq %1,%n3,%0",
  };
  return strings_15[which_alternative];
}

static const char *
output_49 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_49[] = {
    "and %r1,%2,%0",
    "bic %r1,%N2,%0",
    "zapnot %r1,%m2,%0",
  };
  return strings_49[which_alternative];
}

static const char *
output_52 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_52[] = {
    "and %1,0xff,%0",
    "ldbu %0,%1",
  };
  return strings_52[which_alternative];
}

static const char *
output_55 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_55[] = {
    "and %1,0xff,%0",
    "ldbu %0,%1",
  };
  return strings_55[which_alternative];
}

static const char *
output_58 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_58[] = {
    "zapnot %1,3,%0",
    "ldwu %0,%1",
  };
  return strings_58[which_alternative];
}

static const char *
output_61 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_61[] = {
    "zapnot %1,3,%0",
    "ldwu %0,%1",
  };
  return strings_61[which_alternative];
}

static const char *
output_66 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_66[] = {
    "bis %r1,%2,%0",
    "ornot %r1,%N2,%0",
  };
  return strings_66[which_alternative];
}

static const char *
output_69 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_69[] = {
    "xor %r1,%2,%0",
    "eqv %r1,%N2,%0",
  };
  return strings_69[which_alternative];
}

static const char *
output_73 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{

{
  switch (which_alternative)
    {
    case 0:
      if (operands[2] == const1_rtx)
	return "addq %r1,%r1,%0";
      else
	return "s%P2addq %r1,0,%0";
    case 1:
      return "sll %r1,%2,%0";
    default:
      abort();
    }
}
}

static const char *
output_102 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{

{
#if HOST_BITS_PER_WIDE_INT == 64
  if ((unsigned HOST_WIDE_INT) 0xff << INTVAL (operands[2])
      == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
    return "insbl %1,%s2,%0";
  if ((unsigned HOST_WIDE_INT) 0xffff << INTVAL (operands[2])
      == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
    return "inswl %1,%s2,%0";
  if ((unsigned HOST_WIDE_INT) 0xffffffff << INTVAL (operands[2])
      == (unsigned HOST_WIDE_INT) INTVAL (operands[3]))
    return "insll %1,%s2,%0";
#endif
  abort();
}
}

static const char *
output_135 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_135[] = {
    "fmov %1,%0",
    "ld%, %0,%1",
    "st%- %1,%0",
  };
  return strings_135[which_alternative];
}

static const char *
output_164 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_164[] = {
    "cmov%C2 %r3,%1,%0",
    "cmov%D2 %r3,%5,%0",
    "cmov%c2 %r4,%1,%0",
    "cmov%d2 %r4,%5,%0",
  };
  return strings_164[which_alternative];
}

static const char *
output_165 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_165[] = {
    "cmov%C2 %r3,%1,%0",
    "cmov%D2 %r3,%5,%0",
    "cmov%c2 %r4,%1,%0",
    "cmov%d2 %r4,%5,%0",
  };
  return strings_165[which_alternative];
}

static const char *
output_166 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_166[] = {
    "cmovlbc %r2,%1,%0",
    "cmovlbs %r2,%3,%0",
  };
  return strings_166[which_alternative];
}

static const char *
output_167 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_167[] = {
    "cmovlbs %r2,%1,%0",
    "cmovlbc %r2,%3,%0",
  };
  return strings_167[which_alternative];
}

static const char *
output_206 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_206[] = {
    "fcmov%C3 %R4,%R1,%0",
    "fcmov%D3 %R4,%R5,%0",
  };
  return strings_206[which_alternative];
}

static const char *
output_207 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_207[] = {
    "fcmov%C3 %R4,%R1,%0",
    "fcmov%D3 %R4,%R5,%0",
  };
  return strings_207[which_alternative];
}

static const char *
output_208 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_208[] = {
    "fcmov%C3 %R4,%R1,%0",
    "fcmov%D3 %R4,%R5,%0",
  };
  return strings_208[which_alternative];
}

static const char *
output_209 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_209[] = {
    "fcmov%C3 %R4,%R1,%0",
    "fcmov%D3 %R4,%R5,%0",
  };
  return strings_209[which_alternative];
}

static const char *
output_210 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_210[] = {
    "fcmov%C3 %R4,%R1,%0",
    "fcmov%D3 %R4,%R5,%0",
  };
  return strings_210[which_alternative];
}

static const char *
output_211 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_211[] = {
    "fcmov%C3 %R4,%R1,%0",
    "fcmov%D3 %R4,%R5,%0",
  };
  return strings_211[which_alternative];
}

static const char *
output_257 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_257[] = {
    "jsr $26,($27),0\n\tldgp $29,0($26)",
    "bsr $26,$%0..ng",
    "jsr $26,%0\n\tldgp $29,0($26)",
  };
  return strings_257[which_alternative];
}

static const char *
output_258 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_258[] = {
    "jsr $26,(%0)",
    "bsr $26,%0",
    "jsr $26,%0",
  };
  return strings_258[which_alternative];
}

static const char *
output_259 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_259[] = {
    "mov %2,$27\n\tjsr $26,0\n\tldq $27,0($29)",
    "ldq $27,%2\n\tjsr $26,%0\n\tldq $27,0($29)",
  };
  return strings_259[which_alternative];
}

static const char *
output_260 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_260[] = {
    "jsr $26,($27),0\n\tldgp $29,0($26)",
    "bsr $26,$%1..ng",
    "jsr $26,%1\n\tldgp $29,0($26)",
  };
  return strings_260[which_alternative];
}

static const char *
output_261 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_261[] = {
    "jsr $26,(%1)",
    "bsr $26,%1",
    "jsr $26,%1",
  };
  return strings_261[which_alternative];
}

static const char *
output_262 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_262[] = {
    "mov %3,$27\n\tjsr $26,0\n\tldq $27,0($29)",
    "ldq $27,%3\n\tjsr $26,%1\n\tldq $27,0($29)",
  };
  return strings_262[which_alternative];
}

static const char *
output_273 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{

{ rtx best_label = 0;
  rtx jump_table_insn = next_active_insn (operands[1]);

  if (GET_CODE (jump_table_insn) == JUMP_INSN
      && GET_CODE (PATTERN (jump_table_insn)) == ADDR_DIFF_VEC)
    {
      rtx jump_table = PATTERN (jump_table_insn);
      int n_labels = XVECLEN (jump_table, 1);
      int best_count = -1;
      int i, j;

      for (i = 0; i < n_labels; i++)
	{
	  int count = 1;

	  for (j = i + 1; j < n_labels; j++)
	    if (XEXP (XVECEXP (jump_table, 1, i), 0)
		== XEXP (XVECEXP (jump_table, 1, j), 0))
	      count++;

	  if (count > best_count)
	    best_count = count, best_label = XVECEXP (jump_table, 1, i);
	}
    }

  if (best_label)
    {
      operands[3] = best_label;
      return "addq %0,$29,%2\n\tjmp $31,(%2),%3";
    }
  else
    return "addq %0,$29,%2\n\tjmp $31,(%2),0";
}
}

static const char *
output_274 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{

{ rtx best_label = 0;
  rtx jump_table_insn = next_active_insn (operands[1]);

  if (GET_CODE (jump_table_insn) == JUMP_INSN
      && GET_CODE (PATTERN (jump_table_insn)) == ADDR_DIFF_VEC)
    {
      rtx jump_table = PATTERN (jump_table_insn);
      int n_labels = XVECLEN (jump_table, 1);
      int best_count = -1;
      int i, j;

      for (i = 0; i < n_labels; i++)
	{
	  int count = 1;

	  for (j = i + 1; j < n_labels; j++)
	    if (XEXP (XVECEXP (jump_table, 1, i), 0)
		== XEXP (XVECEXP (jump_table, 1, j), 0))
	      count++;

	  if (count > best_count)
	    best_count = count, best_label = XVECEXP (jump_table, 1, i);
	}
    }

  if (best_label)
    {
      operands[2] = best_label;
      return "jmp $31,(%0),%2";
    }
  else
    return "jmp $31,(%0),0";
}
}

static const char *
output_277 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_277[] = {
    "fmov %R1,%0",
    "ld%, %0,%1",
    "mov %r1,%0",
    "ldl %0,%1",
    "st%, %R1,%0",
    "stl %r1,%0",
  };
  return strings_277[which_alternative];
}

static const char *
output_278 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_278[] = {
    "fmov %R1,%0",
    "ld%, %0,%1",
    "mov %r1,%0",
    "ldl %0,%1",
    "st%, %R1,%0",
    "stl %r1,%0",
    "itofs %1,%0",
    "ftois %1,%0",
  };
  return strings_278[which_alternative];
}

static const char *
output_279 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_279[] = {
    "fmov %R1,%0",
    "ld%- %0,%1",
    "mov %r1,%0",
    "ldq %0,%1",
    "st%- %R1,%0",
    "stq %r1,%0",
  };
  return strings_279[which_alternative];
}

static const char *
output_280 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_280[] = {
    "fmov %R1,%0",
    "ld%- %0,%1",
    "mov %r1,%0",
    "ldq %0,%1",
    "st%- %R1,%0",
    "stq %r1,%0",
    "itoft %1,%0",
    "ftoit %1,%0",
  };
  return strings_280[which_alternative];
}

static const char *
output_283 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_283[] = {
    "mov %r1,%0",
    "lda %0,%1",
    "ldah %0,%h1",
    "ldl %0,%1",
    "stl %r1,%0",
    "fmov %R1,%0",
    "ld%, %0,%1",
    "st%, %R1,%0",
  };
  return strings_283[which_alternative];
}

static const char *
output_284 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_284[] = {
    "mov %r1,%0",
    "lda %0,%1",
    "ldah %0,%h1",
    "ldl %0,%1",
    "stl %r1,%0",
    "fmov %R1,%0",
    "ld%, %0,%1",
    "st%, %R1,%0",
    "ftois %1,%0",
    "itofs %1,%0",
  };
  return strings_284[which_alternative];
}

static const char *
output_285 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_285[] = {
    "mov %1,%0",
    "lda %0,%1",
    "ldah %0,%h1",
    "lda %0,%1",
    "ldl %0,%1",
    "stl %r1,%0",
    "fmov %R1,%0",
    "ld%, %0,%1",
    "st%, %R1,%0",
  };
  return strings_285[which_alternative];
}

static const char *
output_286 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_286[] = {
    "mov %r1,%0",
    "lda %0,%L1",
    "fmov %R1,%0",
  };
  return strings_286[which_alternative];
}

static const char *
output_287 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_287[] = {
    "mov %r1,%0",
    "lda %0,%L1",
    "ldwu %0,%1",
    "stw %r1,%0",
    "fmov %R1,%0",
  };
  return strings_287[which_alternative];
}

static const char *
output_288 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_288[] = {
    "mov %r1,%0",
    "lda %0,%L1",
    "fmov %R1,%0",
  };
  return strings_288[which_alternative];
}

static const char *
output_289 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_289[] = {
    "mov %r1,%0",
    "lda %0,%L1",
    "ldbu %0,%1",
    "stb %r1,%0",
    "fmov %R1,%0",
  };
  return strings_289[which_alternative];
}

static const char *
output_292 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_292[] = {
    "mov %r1,%0",
    "lda %0,%1",
    "ldah %0,%h1",
    "lda %0,%1",
    "ldq%A1 %0,%1",
    "stq%A0 %r1,%0",
    "fmov %R1,%0",
    "ldt %0,%1",
    "stt %R1,%0",
  };
  return strings_292[which_alternative];
}

static const char *
output_293 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{
  static const char *const strings_293[] = {
    "mov %r1,%0",
    "lda %0,%1",
    "ldah %0,%h1",
    "lda %0,%1",
    "ldq%A1 %0,%1",
    "stq%A0 %r1,%0",
    "fmov %R1,%0",
    "ldt %0,%1",
    "stt %R1,%0",
    "ftoit %1,%0",
    "itoft %1,%0",
  };
  return strings_293[which_alternative];
}

static const char *
output_324 (operands, insn)
     rtx *operands ATTRIBUTE_UNUSED;
     rtx insn ATTRIBUTE_UNUSED;
{

{
  operands[2] = gen_label_rtx ();
  ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L",
			     CODE_LABEL_NUMBER (operands[2]));

  return "stq $31,-8192(%1)\n\tsubq %0,1,%0\n\tlda %1,-8192(%1)\n\tbne %0,%l2";
}
}

const char * const insn_template[] =
  {
    0,
    0,
    "cvtlq %1,%0",
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    "#",
    0,
    0,
    0,
    0,
    0,
    "#",
    0,
    "#",
    0,
    "#",
    0,
    "#",
    0,
    "subl $31,%1,%0",
    "subl $31,%1,%0",
    "subq $31,%1,%0",
    0,
    "subl %r1,%2,%0",
    "subl %r1,%2,%0",
    "subq %r1,%2,%0",
    "s%2subl %1,%3,%0",
    "s%2subl %1,%3,%0",
    "s%2subq %1,%3,%0",
    "mull %r1,%2,%0",
    "mull %r1,%2,%0",
    "mulq %r1,%2,%0",
    "umulh %r1,%2,%0",
    "umulh %1,%2,%0",
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    "%E1 $24,$25,$27",
    "%E1 $24,$25,$27",
    0,
    0,
    "and %1,0xff,%0",
    0,
    "and %1,0xff,%0",
    0,
    0,
    "and %1,0xff,%0",
    0,
    0,
    "zapnot %1,3,%0",
    0,
    0,
    "zapnot %1,3,%0",
    0,
    "zapnot %1,15,%0",
    "bic %r2,%1,%0",
    0,
    "ornot $31,%1,%0",
    "ornot %r2,%1,%0",
    0,
    "eqv %r1,%2,%0",
    0,
    "cttz %1,%0",
    0,
    "srl %r1,%2,%0",
    "sra %r1,%2,%0",
    0,
    "sextb %1,%0",
    "sextw %1,%0",
    "sextb %1,%0",
    "sextw %1,%0",
    "sextb %1,%0",
    0,
    0,
    0,
    0,
    0,
    0,
    "ext%M2l %r1,%s3,%0",
    "ext%M2l %r1,%3,%0",
    "ext%U3l %1,%2,%0",
    "extql %1,%2,%0",
    "extqh %r1,%2,%0",
    "extlh %r1,%2,%0",
    "extwh %r1,%2,%0",
    "insbl %1,%s2,%0",
    "inswl %1,%s2,%0",
    "insll %1,%s2,%0",
    "insbl %1,%2,%0",
    "inswl %1,%2,%0",
    "insll %1,%2,%0",
    "insql %1,%2,%0",
    0,
    "ins%M2h %1,%3,%0",
    "msk%U2l %r1,%3,%0",
    "msk%M2h %1,%3,%0",
    "cpys $f31,%R1,%0",
    "cpys $f31,%R1,%0",
    "cpysn %R1,%R1,%0",
    "cpysn %R1,%R1,%0",
    "add%,%)%& %R1,%R2,%0",
    "add%,%)%& %R1,%R2,%0",
    "add%-%)%& %R1,%R2,%0",
    "add%-%)%& %R1,%R2,%0",
    "add%-%)%& %R1,%R2,%0",
    "add%-%)%& %R1,%R2,%0",
    "cvtql%` %R1,%0",
    0,
    0,
    "#",
    "#",
    "cvt%-q%(c %R1,%0",
    "cvt%-q%(c %R1,%0",
    0,
    0,
    "#",
    "#",
    "cvt%-q%(c %R1,%0",
    "cvt%-q%(c %R1,%0",
    "cvtq%,%+%& %1,%0",
    "cvtq%,%+%& %1,%0",
    "cvtq%-%+%& %1,%0",
    "cvtq%-%+%& %1,%0",
    0,
    "cvtsts %1,%0",
    0,
    "cvt%-%,%)%& %R1,%0",
    "cvt%-%,%)%& %R1,%0",
    "div%,%)%& %R1,%R2,%0",
    "div%,%)%& %R1,%R2,%0",
    "div%-%)%& %R1,%R2,%0",
    "div%-%)%& %R1,%R2,%0",
    "div%-%)%& %R1,%R2,%0",
    "div%-%)%& %R1,%R2,%0",
    "div%-%)%& %R1,%R2,%0",
    "mul%,%)%& %R1,%R2,%0",
    "mul%,%)%& %R1,%R2,%0",
    "mul%-%)%& %R1,%R2,%0",
    "mul%-%)%& %R1,%R2,%0",
    "mul%-%)%& %R1,%R2,%0",
    "mul%-%)%& %R1,%R2,%0",
    "sub%,%)%& %R1,%R2,%0",
    "sub%,%)%& %R1,%R2,%0",
    "sub%-%)%& %R1,%R2,%0",
    "sub%-%)%& %R1,%R2,%0",
    "sub%-%)%& %R1,%R2,%0",
    "sub%-%)%& %R1,%R2,%0",
    "sub%-%)%& %R1,%R2,%0",
    "sqrt%,%)%& %R1,%0",
    "sqrt%,%)%& %R1,%0",
    "sqrt%-%)%& %R1,%0",
    "sqrt%-%)%& %1,%0",
    "cmp%C1 %r2,%3,%0",
    "cmp%c1 %r3,%2,%0",
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    "minsb8 %r1,%2,%0",
    "minub8 %r1,%2,%0",
    "maxsb8 %r1,%2,%0",
    "maxub8 %r1,%2,%0",
    "minsw4 %r1,%2,%0",
    "minuw4 %r1,%2,%0",
    "maxsw4 %r1,%2,%0",
    "maxuw4 %r1,%2,%0",
    0,
    0,
    "cmovlt %0,0,%0",
    0,
    0,
    "cmovgt %0,0,%0",
    0,
    0,
    0,
    0,
    "b%C1 %r2,%0",
    "b%c1 %2,%0",
    "blbs %r1,%0",
    "blbc %r1,%0",
    0,
    "cmp%-%C1%' %R2,%R3,%0",
    "cmp%-%C1%' %R2,%R3,%0",
    "cmp%-%C1%' %R2,%R3,%0",
    "cmp%-%C1%' %R2,%R3,%0",
    "cmp%-%C1%' %R2,%R3,%0",
    "cmp%-%C1%' %R2,%R3,%0",
    "cmp%-%C1%' %R2,%R3,%0",
    "cmp%-%C1%' %R2,%R3,%0",
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    "fb%C1 %R2,%0",
    "fb%C1 %R2,%0",
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    "",
    "br $31,%l0",
    "ret $31,($26),1",
    "ret $31,($26),1",
    "jmp $31,(%0),0",
    0,
    0,
    0,
    0,
    0,
    0,
    "jmp $31,(%0),0",
    "call_pal 0x86",
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    "#",
    "#",
    "#",
    "#",
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    "mov %1,%0",
    0,
    0,
    "lda %0,%1(%0)",
    0,
    "\n$LSJ%=:\n\tldgp $29,$LSJ%=-%l0($27)",
    "br $29,$LSJ%=\n$LSJ%=:\n\tldgp $29,0($29)",
    "br $29,$LSJ%=\n$LSJ%=:\n\tldgp $29,0($29)",
    0,
    "lda $0,OTS$HOME_ARGS\n\tldq $0,8($0)\n\tjsr $0,OTS$HOME_ARGS",
    "trapb",
    "nop",
    "fnop",
    "unop",
    ".align %0 #realign",
  };

const char *(*const insn_outfun[])() =
  {
    output_0,
    0,
    0,
    0,
    output_4,
    0,
    output_6,
    0,
    0,
    output_9,
    0,
    0,
    output_12,
    output_13,
    0,
    output_15,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_49,
    0,
    0,
    output_52,
    0,
    0,
    output_55,
    0,
    0,
    output_58,
    0,
    0,
    output_61,
    0,
    0,
    0,
    0,
    output_66,
    0,
    0,
    output_69,
    0,
    0,
    0,
    output_73,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_102,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_135,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_164,
    output_165,
    output_166,
    output_167,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_206,
    output_207,
    output_208,
    output_209,
    output_210,
    output_211,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_257,
    output_258,
    output_259,
    output_260,
    output_261,
    output_262,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_273,
    output_274,
    0,
    0,
    output_277,
    output_278,
    output_279,
    output_280,
    0,
    0,
    output_283,
    output_284,
    output_285,
    output_286,
    output_287,
    output_288,
    output_289,
    0,
    0,
    output_292,
    output_293,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    output_324,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
  };

rtx (*const insn_gen_function[]) () =
  {
    gen_extendsidi2,
    0,
    0,
    gen_addsi3,
    0,
    0,
    0,
    0,
    0,
    gen_adddi3,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    gen_negsi2,
    0,
    gen_negdi2,
    gen_subsi3,
    0,
    0,
    gen_subdi3,
    0,
    0,
    0,
    gen_mulsi3,
    0,
    gen_muldi3,
    gen_umuldi3_highpart,
    0,
    gen_divsi3,
    gen_udivsi3,
    gen_modsi3,
    gen_umodsi3,
    gen_divdi3,
    gen_udivdi3,
    gen_moddi3,
    gen_umoddi3,
    0,
    0,
    gen_anddi3,
    0,
    gen_zero_extendqihi2,
    0,
    0,
    gen_zero_extendqisi2,
    0,
    0,
    gen_zero_extendqidi2,
    0,
    0,
    gen_zero_extendhisi2,
    0,
    0,
    gen_zero_extendhidi2,
    gen_zero_extendsidi2,
    0,
    gen_iordi3,
    gen_one_cmpldi2,
    0,
    gen_xordi3,
    0,
    gen_ffsdi2,
    0,
    gen_ashldi3,
    gen_lshrdi3,
    gen_ashrdi3,
    gen_extendqihi2,
    gen_extendqidi2x,
    gen_extendhidi2x,
    gen_extendqisi2x,
    gen_extendhisi2x,
    gen_extendqihi2x,
    gen_extendqisi2,
    gen_extendqidi2,
    gen_extendhisi2,
    gen_extendhidi2,
    gen_unaligned_extendqidi,
    gen_unaligned_extendhidi,
    0,
    gen_extxl,
    0,
    0,
    gen_extqh,
    gen_extlh,
    gen_extwh,
    0,
    0,
    0,
    gen_insbl,
    gen_inswl,
    gen_insll,
    gen_insql,
    0,
    gen_insxh,
    gen_mskxl,
    gen_mskxh,
    gen_abssf2,
    gen_absdf2,
    gen_negsf2,
    gen_negdf2,
    0,
    gen_addsf3,
    0,
    gen_adddf3,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    gen_fix_truncdfdi2,
    0,
    0,
    0,
    0,
    0,
    gen_fix_truncsfdi2,
    0,
    gen_floatdisf2,
    0,
    gen_floatdidf2,
    gen_extendsfdf2,
    gen_extendsfdf2_tp,
    gen_extendsfdf2_no_tp,
    0,
    gen_truncdfsf2,
    0,
    gen_divsf3,
    0,
    gen_divdf3,
    0,
    0,
    0,
    0,
    gen_mulsf3,
    0,
    gen_muldf3,
    0,
    0,
    0,
    gen_subsf3,
    0,
    gen_subdf3,
    0,
    0,
    0,
    0,
    gen_sqrtsf2,
    0,
    gen_sqrtdf2,
    0,
    0,
    0,
    0,
    0,
    0,
    gen_absdi2,
    gen_absdi2_same,
    gen_absdi2_diff,
    0,
    0,
    0,
    0,
    gen_sminqi3,
    gen_uminqi3,
    gen_smaxqi3,
    gen_umaxqi3,
    gen_sminhi3,
    gen_uminhi3,
    gen_smaxhi3,
    gen_umaxhi3,
    gen_smaxdi3,
    0,
    0,
    gen_smindi3,
    0,
    0,
    gen_umaxdi3,
    0,
    gen_umindi3,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    gen_maxdf3,
    gen_mindf3,
    gen_maxsf3,
    gen_minsf3,
    0,
    0,
    gen_cmpdf,
    gen_cmpdi,
    gen_beq,
    gen_bne,
    gen_blt,
    gen_ble,
    gen_bgt,
    gen_bge,
    gen_bltu,
    gen_bleu,
    gen_bgtu,
    gen_bgeu,
    gen_seq,
    gen_sne,
    gen_slt,
    gen_sle,
    gen_sgt,
    gen_sge,
    gen_sltu,
    gen_sleu,
    gen_sgtu,
    gen_sgeu,
    gen_movsicc,
    gen_movdicc,
    gen_movsfcc,
    gen_movdfcc,
    0,
    0,
    0,
    0,
    0,
    gen_call,
    gen_call_osf,
    gen_call_nt,
    gen_call_vms,
    gen_call_value,
    gen_call_value_osf,
    gen_call_value_nt,
    gen_call_value_vms,
    0,
    0,
    0,
    0,
    0,
    0,
    gen_untyped_call,
    gen_blockage,
    gen_jump,
    gen_return,
    gen_return_internal,
    gen_indirect_jump,
    gen_tablejump,
    gen_tablejump_osf,
    gen_tablejump_nt,
    gen_tablejump_vms,
    0,
    0,
    0,
    gen_imb,
    0,
    0,
    0,
    0,
    gen_movsf,
    gen_movdf,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    gen_movsi,
    0,
    0,
    0,
    gen_movdi,
    0,
    gen_aligned_loadqi,
    gen_aligned_loadhi,
    gen_unaligned_loadqi,
    gen_unaligned_loadhi,
    gen_aligned_store,
    gen_unaligned_storeqi,
    gen_unaligned_storehi,
    gen_movqi,
    gen_movhi,
    gen_reload_inqi,
    gen_reload_inhi,
    gen_reload_outqi,
    gen_reload_outhi,
    gen_reload_inqi_help,
    gen_reload_inhi_help,
    gen_reload_outqi_help,
    gen_reload_outhi_help,
    0,
    0,
    0,
    0,
    gen_extv,
    gen_extzv,
    gen_insv,
    gen_movstrqi,
    gen_clrstrqi,
    gen_probe_stack,
    gen_allocate_stack,
    gen_prologue_stack_probe_loop,
    gen_prologue,
    gen_init_fp,
    gen_epilogue,
    gen_eh_epilogue,
    gen_nt_lda,
    gen_builtin_longjmp,
    gen_builtin_setjmp_receiver,
    0,
    gen_exception_receiver,
    gen_nonlocal_goto_receiver,
    gen_arg_home,
    gen_trapb,
    gen_nop,
    gen_fnop,
    gen_unop,
    gen_realign,
  };

const char *insn_name[] =
  {
    "extendsidi2",
    "extendsidi2+1",
    "addsi3-1",
    "addsi3",
    "addsi3+1",
    "addsi3+2",
    "addsi3+3",
    "adddi3-2",
    "adddi3-1",
    "adddi3",
    "adddi3+1",
    "adddi3+2",
    "adddi3+3",
    "adddi3+4",
    "adddi3+5",
    "adddi3+6",
    "adddi3+7",
    "negsi2-7",
    "negsi2-6",
    "negsi2-5",
    "negsi2-4",
    "negsi2-3",
    "negsi2-2",
    "negsi2-1",
    "negsi2",
    "negsi2+1",
    "negdi2",
    "subsi3",
    "subsi3+1",
    "subdi3-1",
    "subdi3",
    "subdi3+1",
    "subdi3+2",
    "mulsi3-1",
    "mulsi3",
    "mulsi3+1",
    "muldi3",
    "umuldi3_highpart",
    "umuldi3_highpart+1",
    "divsi3",
    "udivsi3",
    "modsi3",
    "umodsi3",
    "divdi3",
    "udivdi3",
    "moddi3",
    "umoddi3",
    "umoddi3+1",
    "anddi3-1",
    "anddi3",
    "anddi3+1",
    "zero_extendqihi2",
    "zero_extendqihi2+1",
    "zero_extendqisi2-1",
    "zero_extendqisi2",
    "zero_extendqisi2+1",
    "zero_extendqidi2-1",
    "zero_extendqidi2",
    "zero_extendqidi2+1",
    "zero_extendhisi2-1",
    "zero_extendhisi2",
    "zero_extendhisi2+1",
    "zero_extendhidi2-1",
    "zero_extendhidi2",
    "zero_extendsidi2",
    "zero_extendsidi2+1",
    "iordi3",
    "one_cmpldi2",
    "one_cmpldi2+1",
    "xordi3",
    "xordi3+1",
    "ffsdi2",
    "ffsdi2+1",
    "ashldi3",
    "lshrdi3",
    "ashrdi3",
    "extendqihi2",
    "extendqidi2x",
    "extendhidi2x",
    "extendqisi2x",
    "extendhisi2x",
    "extendqihi2x",
    "extendqisi2",
    "extendqidi2",
    "extendhisi2",
    "extendhidi2",
    "unaligned_extendqidi",
    "unaligned_extendhidi",
    "unaligned_extendhidi+1",
    "extxl",
    "extxl+1",
    "extqh-1",
    "extqh",
    "extlh",
    "extwh",
    "extwh+1",
    "extwh+2",
    "insbl-1",
    "insbl",
    "inswl",
    "insll",
    "insql",
    "insql+1",
    "insxh",
    "mskxl",
    "mskxh",
    "abssf2",
    "absdf2",
    "negsf2",
    "negdf2",
    "negdf2+1",
    "addsf3",
    "addsf3+1",
    "adddf3",
    "adddf3+1",
    "*cvtql-1",
    "*cvtql",
    "*cvtql+1",
    "*cvtql+2",
    "*cvtql+3",
    "fix_truncdfdi2-2",
    "fix_truncdfdi2-1",
    "fix_truncdfdi2",
    "fix_truncdfdi2+1",
    "fix_truncdfdi2+2",
    "fix_truncdfdi2+3",
    "fix_truncsfdi2-2",
    "fix_truncsfdi2-1",
    "fix_truncsfdi2",
    "fix_truncsfdi2+1",
    "floatdisf2",
    "floatdisf2+1",
    "floatdidf2",
    "extendsfdf2",
    "extendsfdf2_tp",
    "extendsfdf2_no_tp",
    "extendsfdf2_no_tp+1",
    "truncdfsf2",
    "truncdfsf2+1",
    "divsf3",
    "divsf3+1",
    "divdf3",
    "divdf3+1",
    "divdf3+2",
    "mulsf3-2",
    "mulsf3-1",
    "mulsf3",
    "mulsf3+1",
    "muldf3",
    "muldf3+1",
    "muldf3+2",
    "subsf3-1",
    "subsf3",
    "subsf3+1",
    "subdf3",
    "subdf3+1",
    "subdf3+2",
    "sqrtsf2-2",
    "sqrtsf2-1",
    "sqrtsf2",
    "sqrtsf2+1",
    "sqrtdf2",
    "sqrtdf2+1",
    "sqrtdf2+2",
    "sqrtdf2+3",
    "absdi2-3",
    "absdi2-2",
    "absdi2-1",
    "absdi2",
    "absdi2_same",
    "absdi2_diff",
    "absdi2_diff+1",
    "absdi2_diff+2",
    "sminqi3-2",
    "sminqi3-1",
    "sminqi3",
    "uminqi3",
    "smaxqi3",
    "umaxqi3",
    "sminhi3",
    "uminhi3",
    "smaxhi3",
    "umaxhi3",
    "smaxdi3",
    "smaxdi3+1",
    "smindi3-1",
    "smindi3",
    "smindi3+1",
    "umaxdi3-1",
    "umaxdi3",
    "umaxdi3+1",
    "umindi3",
    "umindi3+1",
    "umindi3+2",
    "umindi3+3",
    "umindi3+4",
    "umindi3+5",
    "umindi3+6",
    "umindi3+7",
    "umindi3+8",
    "umindi3+9",
    "umindi3+10",
    "maxdf3-10",
    "maxdf3-9",
    "maxdf3-8",
    "maxdf3-7",
    "maxdf3-6",
    "maxdf3-5",
    "maxdf3-4",
    "maxdf3-3",
    "maxdf3-2",
    "maxdf3-1",
    "maxdf3",
    "mindf3",
    "maxsf3",
    "minsf3",
    "minsf3+1",
    "cmpdf-1",
    "cmpdf",
    "cmpdi",
    "beq",
    "bne",
    "blt",
    "ble",
    "bgt",
    "bge",
    "bltu",
    "bleu",
    "bgtu",
    "bgeu",
    "seq",
    "sne",
    "slt",
    "sle",
    "sgt",
    "sge",
    "sltu",
    "sleu",
    "sgtu",
    "sgeu",
    "movsicc",
    "movdicc",
    "movsfcc",
    "movdfcc",
    "movdfcc+1",
    "movdfcc+2",
    "movdfcc+3",
    "call-2",
    "call-1",
    "call",
    "call_osf",
    "call_nt",
    "call_vms",
    "call_value",
    "call_value_osf",
    "call_value_nt",
    "call_value_vms",
    "call_value_vms+1",
    "call_value_vms+2",
    "call_value_vms+3",
    "untyped_call-3",
    "untyped_call-2",
    "untyped_call-1",
    "untyped_call",
    "blockage",
    "jump",
    "return",
    "return_internal",
    "indirect_jump",
    "tablejump",
    "tablejump_osf",
    "tablejump_nt",
    "tablejump_vms",
    "tablejump_vms+1",
    "tablejump_vms+2",
    "imb-1",
    "imb",
    "imb+1",
    "imb+2",
    "movsf-2",
    "movsf-1",
    "movsf",
    "movdf",
    "movdf+1",
    "movdf+2",
    "movdf+3",
    "movdf+4",
    "movsi-3",
    "movsi-2",
    "movsi-1",
    "movsi",
    "movsi+1",
    "movsi+2",
    "movdi-1",
    "movdi",
    "movdi+1",
    "aligned_loadqi",
    "aligned_loadhi",
    "unaligned_loadqi",
    "unaligned_loadhi",
    "aligned_store",
    "unaligned_storeqi",
    "unaligned_storehi",
    "movqi",
    "movhi",
    "reload_inqi",
    "reload_inhi",
    "reload_outqi",
    "reload_outhi",
    "reload_inqi_help",
    "reload_inhi_help",
    "reload_outqi_help",
    "reload_outhi_help",
    "reload_outhi_help+1",
    "reload_outhi_help+2",
    "extv-2",
    "extv-1",
    "extv",
    "extzv",
    "insv",
    "movstrqi",
    "clrstrqi",
    "probe_stack",
    "allocate_stack",
    "prologue_stack_probe_loop",
    "prologue",
    "init_fp",
    "epilogue",
    "eh_epilogue",
    "nt_lda",
    "builtin_longjmp",
    "builtin_setjmp_receiver",
    "builtin_setjmp_receiver+1",
    "exception_receiver",
    "nonlocal_goto_receiver",
    "arg_home",
    "trapb",
    "nop",
    "fnop",
    "unop",
    "realign",
  };
const char **insn_name_ptr = insn_name;

const int insn_n_operands[] =
  {
    2,
    2,
    2,
    3,
    3,
    3,
    3,
    4,
    6,
    3,
    3,
    3,
    4,
    4,
    7,
    4,
    4,
    4,
    5,
    5,
    5,
    5,
    5,
    5,
    2,
    2,
    2,
    3,
    3,
    3,
    3,
    4,
    4,
    4,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    2,
    2,
    3,
    3,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    3,
    3,
    2,
    3,
    3,
    3,
    2,
    2,
    3,
    3,
    3,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    4,
    4,
    4,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    4,
    4,
    4,
    4,
    2,
    2,
    2,
    2,
    3,
    3,
    3,
    3,
    3,
    3,
    2,
    4,
    3,
    4,
    3,
    2,
    2,
    4,
    3,
    4,
    3,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    2,
    2,
    2,
    2,
    4,
    4,
    6,
    6,
    4,
    4,
    2,
    2,
    2,
    3,
    2,
    3,
    2,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    3,
    4,
    2,
    3,
    4,
    2,
    3,
    4,
    3,
    4,
    3,
    3,
    2,
    2,
    5,
    4,
    4,
    4,
    4,
    4,
    4,
    4,
    4,
    6,
    6,
    6,
    6,
    6,
    6,
    3,
    3,
    3,
    3,
    4,
    4,
    2,
    2,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    4,
    4,
    4,
    4,
    7,
    7,
    5,
    5,
    5,
    4,
    2,
    2,
    2,
    5,
    3,
    3,
    3,
    2,
    2,
    3,
    3,
    3,
    4,
    3,
    0,
    1,
    0,
    0,
    1,
    2,
    3,
    2,
    2,
    3,
    2,
    2,
    0,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    2,
    4,
    4,
    4,
    4,
    5,
    5,
    5,
    2,
    2,
    3,
    3,
    3,
    3,
    3,
    3,
    4,
    4,
    3,
    3,
    4,
    4,
    4,
    4,
    4,
    4,
    3,
    1,
    2,
    2,
    0,
    3,
    0,
    3,
    2,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
  };

const int insn_n_dups[] =
  {
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    5,
    0,
    0,
    0,
    0,
    2,
    0,
    0,
    0,
    0,
    0,
    2,
    2,
    2,
    2,
    7,
    7,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    4,
    4,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    4,
    0,
    0,
    4,
    0,
    0,
    4,
    0,
    4,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    5,
    5,
    5,
    5,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    3,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    0,
    0,
    0,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    2,
    2,
    2,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    3,
    3,
    8,
    10,
    10,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
  };

const char *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =
  {
    { "=r,r,?f", "r,m,m", },
    { "", "", },
    { "=f", "f", },
    { "", "", "", },
    { "=r,r,r,r", "%rJ,rJ,rJ,rJ", "rI,O,K,L", },
    { "", "", "", },
    { "=r,r", "%rJ,rJ", "rI,O", },
    { "", "", "", "", },
    { "", "", "", "", "", "", },
    { "=r,r,r,r", "%rJ,rJ,rJ,rJ", "rI,O,K,L", },
    { "=r", "r", "n", },
    { "", "", "", },
    { "=r,r", "r,r", "I,I", "rI,O", },
    { "=r,r", "r,r", "I,I", "rI,O", },
    { "", "", "", "", "", "", "", },
    { "=r,r", "r,r", "I,I", "rI,O", },
    { "=&r", "r", "r", "rIOKL", },
    { "", "", "", "", },
    { "=&r", "rJ", "I", "r", "rIOKL", },
    { "", "", "", "", "", },
    { "=&r", "rJ", "I", "r", "rIOKL", },
    { "", "", "", "", "", },
    { "=&r", "rJ", "I", "r", "rIOKL", },
    { "", "", "", "", "", },
    { "=r", "rI", },
    { "=r", "rI", },
    { "=r", "rI", },
    { "", "", "", },
    { "=r", "rJ", "rI", },
    { "=r", "rJ", "rI", },
    { "=r", "rJ", "rI", },
    { "=r", "r", "I", "rI", },
    { "=r", "r", "I", "rI", },
    { "=r", "r", "I", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "r", "I", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", },
    { "", "", },
    { "=r,r,r", "%rJ,rJ,rJ", "rI,N,MH", },
    { "", "", "", },
    { "=r", "r", },
    { "=r,r", "r,m", },
    { "=r", "r", },
    { "", "", },
    { "=r,r", "r,m", },
    { "=r", "r", },
    { "", "", },
    { "=r,r", "r,m", },
    { "=r", "r", },
    { "", "", },
    { "=r,r", "r,m", },
    { "=r", "r", },
    { "", "", },
    { "=r", "r", },
    { "=r", "rI", "rJ", },
    { "=r,r", "%rJ,rJ", "rI,N", },
    { "=r", "rI", },
    { "=r", "rI", "rJ", },
    { "=r,r", "%rJ,rJ", "rI,N", },
    { "=r", "%rJ", "rI", },
    { "", "", },
    { "=r", "r", },
    { "=r,r", "rJ,rJ", "P,rS", },
    { "=r", "rJ", "rS", },
    { "=r", "rJ", "rS", },
    { "", "", },
    { "=r", "r", },
    { "=r", "r", },
    { "=r", "r", },
    { "=r", "r", },
    { "=r", "r", },
    { "", "", },
    { "", "", },
    { "", "", },
    { "", "", },
    { "", "", },
    { "", "", },
    { "=r", "rJ", "n", "I", },
    { "=r", "rJ", "n", "rI", },
    { "=r", "rJ", "rI", "n", },
    { "=r", "rJ", "rI", },
    { "=r", "rJ", "rI", },
    { "=r", "rJ", "rI", },
    { "=r", "rJ", "rI", },
    { "=r", "r", "I", },
    { "=r", "r", "I", },
    { "=r", "r", "I", },
    { "=r", "r", "rI", },
    { "=r", "r", "rI", },
    { "=r", "r", "rI", },
    { "=r", "r", "rI", },
    { "=r", "r", "I", "i", },
    { "=r", "r", "n", "rI", },
    { "=r", "rJ", "n", "rI", },
    { "=r", "r", "n", "rI", },
    { "=f", "fG", },
    { "=f", "fG", },
    { "=f", "fG", },
    { "=f", "fG", },
    { "=&f", "%fG", "fG", },
    { "=f", "%fG", "fG", },
    { "=&f", "%fG", "fG", },
    { "=f", "%fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "%fG", "fG", },
    { "=f", "fG", },
    { "", "", "", "", },
    { "", "", "", },
    { "=m", "fG", "=&f", "=&f", },
    { "=m", "fG", "=f", },
    { "=&f", "fG", },
    { "=f", "fG", },
    { "", "", "", "", },
    { "", "", "", },
    { "=m", "fG", "=&f", "=&f", },
    { "=m", "fG", "=f", },
    { "=&f", "fG", },
    { "=f", "fG", },
    { "=&f", "f", },
    { "=f", "f", },
    { "=&f", "f", },
    { "=f", "f", },
    { "", "", },
    { "=&f", "f", },
    { "=f,f,m", "f,m,f", },
    { "=&f", "fG", },
    { "=f", "fG", },
    { "=&f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=&f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=&f", "%fG", "fG", },
    { "=f", "%fG", "fG", },
    { "=&f", "%fG", "fG", },
    { "=f", "%fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "%fG", "fG", },
    { "=&f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=&f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=f", "fG", "fG", },
    { "=&f", "fG", },
    { "=f", "fG", },
    { "=&f", "fG", },
    { "=f", "fG", },
    { "=r", "", "rJ", "rI", },
    { "=r", "", "rI", "rJ", },
    { "=r,r,r,r", "rI,0,rI,0", "", "rJ,rJ,J,J", "J,J,rJ,rJ", "0,rI,0,rI", },
    { "=r,r,r,r", "rI,0,rI,0", "", "rJ,rJ,J,J", "J,J,rJ,rJ", "0,rI,0,rI", },
    { "=r,r", "rI,0", "rJ,rJ", "0,rI", },
    { "=r,r", "rI,0", "rJ,rJ", "0,rI", },
    { "", "", },
    { "", "", },
    { "", "", },
    { "", "", "", },
    { "", "", },
    { "", "", "", },
    { "", "", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "=r", "%rJ", "rI", },
    { "", "", "", },
    { "", "", "", "", },
    { "=r", "0", },
    { "", "", "", },
    { "", "", "", "", },
    { "=r", "0", },
    { "", "", "", },
    { "", "", "", "", },
    { "", "", "", },
    { "", "", "", "", },
    { "", "", "rJ", },
    { "", "", "r", },
    { "", "rJ", },
    { "", "rJ", },
    { "", "", "", "", "", },
    { "=&f", "", "fG", "fG", },
    { "=f", "", "fG", "fG", },
    { "=&f", "", "fG", "fG", },
    { "=f", "", "fG", "fG", },
    { "=&f", "", "fG", "fG", },
    { "=f", "", "fG", "fG", },
    { "=&f", "", "fG", "fG", },
    { "=f", "", "fG", "fG", },
    { "=f,f", "fG,0", "G,G", "", "fG,fG", "0,fG", },
    { "=f,f", "fG,0", "G,G", "", "fG,fG", "0,fG", },
    { "=f,f", "fG,0", "G,G", "", "fG,fG", "0,fG", },
    { "=f,f", "fG,0", "G,G", "", "fG,fG", "0,fG", },
    { "=f,f", "fG,0", "G,G", "", "fG,fG", "0,fG", },
    { "=f,f", "fG,0", "G,G", "", "fG,fG", "0,fG", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "fG", "G", },
    { "", "", "fG", "G", },
    { "", "", },
    { "", "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", "", "", "", },
    { "", "", "", "", "", "", "", },
    { "", "", "", "", "", },
    { "", "", "", "", "", },
    { "", "", "", "", "", },
    { "", "", "", "", },
    { "", "", },
    { "", "", },
    { "", "", },
    { "", "", "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", },
    { "r,R,i", "", },
    { "r,R,i", "", },
    { "r,i", "", "r,m", },
    { "=rf,rf,rf", "r,R,i", "", },
    { "=rf,rf,rf", "r,R,i", "", },
    { "", "r,i", "", "r,m", },
    { "", "", "", },
    { 0 },
    { "", },
    { 0 },
    { 0 },
    { "r", },
    { "", "", },
    { "", "", "=r", },
    { "", "", },
    { "", "", },
    { "r", "", "=r", },
    { "r", "", },
    { "r", "", },
    { 0 },
    { "=f,f,r,r,m,m", "fG,m,rG,m,fG,r", },
    { "=f,f,r,r,m,m,f,*r", "fG,m,rG,m,fG,r,r,*f", },
    { "=f,f,r,r,m,m", "fG,m,rG,m,fG,r", },
    { "=f,f,r,r,m,m,f,*r", "fG,m,rG,m,fG,r,r,*f", },
    { "", "", },
    { "", "", },
    { "=r,r,r,r,m,f,f,m", "rJ,K,L,m,rJ,fJ,m,f", },
    { "=r,r,r,r,m,f,f,m,r,*f", "rJ,K,L,m,rJ,fJ,m,f,f,*r", },
    { "=r,r,r,r,r,m,f,f,m", "rJ,K,L,s,m,rJ,fJ,m,f", },
    { "=r,r,f", "rJ,n,fJ", },
    { "=r,r,r,m,f", "rJ,n,m,rJ,fJ", },
    { "=r,r,f", "rJ,n,fJ", },
    { "=r,r,r,m,f", "rJ,n,m,rJ,fJ", },
    { "", "", },
    { "", "", },
    { "=r,r,r,r,r,m,f,f,Q", "rJ,K,L,s,m,rJ,fJ,Q,f", },
    { "=r,r,r,r,r,m,f,f,Q,r,*f", "rJ,K,L,s,m,rJ,fJ,Q,f,f,*r", },
    { "", "", },
    { "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", "", },
    { "", "", "", "", "", },
    { "", "", "", "", "", },
    { "", "", },
    { "", "", },
    { "=r", "m", "=&r", },
    { "=r", "m", "=&r", },
    { "=m", "r", "=&r", },
    { "=m", "r", "=&r", },
    { "r", "m", "r", },
    { "r", "m", "r", },
    { "m", "r", "r", "r", },
    { "m", "r", "r", "r", },
    { "", "", "", },
    { "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", "", },
    { "", "", "", },
    { "", },
    { "=r", "", },
    { "r", "r", },
    { 0 },
    { "r", "r", "r", },
    { 0 },
    { "r", "r", "r", },
    { "r", "n", },
    { "r", },
    { "", },
    { "", },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { "i", },
  };

const enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =
  {
    { DImode, SImode, },
    { VOIDmode, VOIDmode, },
    { DImode, SImode, },
    { SImode, SImode, SImode, },
    { SImode, SImode, SImode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { DImode, SImode, SImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { SImode, SImode, SImode, SImode, },
    { DImode, SImode, SImode, SImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { SImode, SImode, SImode, SImode, SImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, SImode, SImode, SImode, SImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, DImode, DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { SImode, SImode, },
    { DImode, SImode, },
    { DImode, DImode, },
    { SImode, SImode, SImode, },
    { SImode, SImode, SImode, },
    { DImode, SImode, SImode, },
    { DImode, DImode, DImode, },
    { SImode, SImode, SImode, SImode, },
    { DImode, SImode, SImode, SImode, },
    { DImode, DImode, DImode, DImode, },
    { SImode, SImode, SImode, },
    { DImode, SImode, SImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, TImode, },
    { SImode, SImode, SImode, },
    { SImode, SImode, SImode, },
    { SImode, SImode, SImode, },
    { SImode, SImode, SImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { VOIDmode, SImode, },
    { VOIDmode, DImode, },
    { DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { HImode, QImode, },
    { SImode, QImode, },
    { SImode, QImode, },
    { SImode, QImode, },
    { DImode, QImode, },
    { DImode, QImode, },
    { DImode, QImode, },
    { SImode, HImode, },
    { SImode, HImode, },
    { SImode, HImode, },
    { DImode, HImode, },
    { DImode, HImode, },
    { DImode, HImode, },
    { DImode, SImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, },
    { DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { HImode, QImode, },
    { DImode, QImode, },
    { DImode, HImode, },
    { SImode, QImode, },
    { SImode, HImode, },
    { HImode, QImode, },
    { SImode, QImode, },
    { DImode, QImode, },
    { SImode, HImode, },
    { DImode, HImode, },
    { QImode, DImode, },
    { QImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, QImode, DImode, },
    { DImode, HImode, DImode, },
    { DImode, SImode, DImode, },
    { DImode, QImode, DImode, },
    { DImode, HImode, DImode, },
    { DImode, SImode, DImode, },
    { DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { SFmode, SFmode, },
    { DFmode, DFmode, },
    { SFmode, SFmode, },
    { DFmode, DFmode, },
    { SFmode, SFmode, SFmode, },
    { SFmode, SFmode, SFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, SFmode, DFmode, },
    { DFmode, SFmode, SFmode, },
    { SImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { SImode, DFmode, DImode, SImode, },
    { SImode, DFmode, DImode, },
    { DImode, DFmode, },
    { DImode, DFmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { SImode, SFmode, DImode, SImode, },
    { SImode, SFmode, DImode, },
    { DImode, SFmode, },
    { DImode, SFmode, },
    { SFmode, DImode, },
    { SFmode, DImode, },
    { DFmode, DImode, },
    { DFmode, DImode, },
    { DFmode, SFmode, },
    { DFmode, SFmode, },
    { DFmode, SFmode, },
    { SFmode, DFmode, },
    { SFmode, DFmode, },
    { SFmode, SFmode, SFmode, },
    { SFmode, SFmode, SFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, SFmode, DFmode, },
    { DFmode, DFmode, SFmode, },
    { DFmode, SFmode, SFmode, },
    { SFmode, SFmode, SFmode, },
    { SFmode, SFmode, SFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, SFmode, DFmode, },
    { DFmode, SFmode, SFmode, },
    { SFmode, SFmode, SFmode, },
    { SFmode, SFmode, SFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, SFmode, DFmode, },
    { DFmode, DFmode, SFmode, },
    { DFmode, SFmode, SFmode, },
    { SFmode, SFmode, },
    { SFmode, SFmode, },
    { DFmode, DFmode, },
    { DFmode, DFmode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { SImode, SImode, VOIDmode, DImode, DImode, SImode, },
    { DImode, DImode, VOIDmode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { DImode, DImode, },
    { DImode, DImode, },
    { DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, },
    { QImode, QImode, QImode, },
    { QImode, QImode, QImode, },
    { QImode, QImode, QImode, },
    { QImode, QImode, QImode, },
    { HImode, HImode, HImode, },
    { HImode, HImode, HImode, },
    { HImode, HImode, HImode, },
    { HImode, HImode, HImode, },
    { DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, DImode, },
    { DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, DImode, },
    { DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, DImode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, DImode, },
    { VOIDmode, VOIDmode, DImode, },
    { VOIDmode, DImode, },
    { VOIDmode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DFmode, DFmode, DFmode, DFmode, },
    { DFmode, DFmode, DFmode, DFmode, },
    { DFmode, DFmode, SFmode, DFmode, },
    { DFmode, DFmode, SFmode, DFmode, },
    { DFmode, DFmode, DFmode, SFmode, },
    { DFmode, DFmode, DFmode, SFmode, },
    { DFmode, DFmode, SFmode, SFmode, },
    { DFmode, DFmode, SFmode, SFmode, },
    { DFmode, DFmode, DFmode, VOIDmode, DFmode, DFmode, },
    { SFmode, SFmode, DFmode, VOIDmode, DFmode, SFmode, },
    { DFmode, SFmode, DFmode, VOIDmode, DFmode, DFmode, },
    { DFmode, DFmode, DFmode, VOIDmode, SFmode, DFmode, },
    { SFmode, SFmode, DFmode, VOIDmode, SFmode, SFmode, },
    { DFmode, SFmode, DFmode, VOIDmode, SFmode, DFmode, },
    { DFmode, DFmode, DFmode, },
    { DFmode, DFmode, DFmode, },
    { SFmode, SFmode, SFmode, },
    { SFmode, SFmode, SFmode, },
    { VOIDmode, VOIDmode, DFmode, DFmode, },
    { VOIDmode, VOIDmode, SFmode, DFmode, },
    { DFmode, DFmode, },
    { DImode, DImode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { DImode, },
    { SImode, VOIDmode, SImode, SImode, },
    { DImode, VOIDmode, DImode, DImode, },
    { SFmode, VOIDmode, SFmode, SFmode, },
    { DFmode, VOIDmode, DFmode, DFmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, },
    { VOIDmode, DImode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, DImode, VOIDmode, },
    { DImode, VOIDmode, },
    { DImode, VOIDmode, },
    { DImode, VOIDmode, DImode, },
    { VOIDmode, DImode, VOIDmode, },
    { VOIDmode, DImode, VOIDmode, },
    { VOIDmode, DImode, VOIDmode, DImode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode },
    { VOIDmode, },
    { VOIDmode },
    { VOIDmode },
    { DImode, },
    { SImode, SImode, },
    { SImode, VOIDmode, DImode, },
    { SImode, VOIDmode, },
    { DImode, VOIDmode, },
    { DImode, VOIDmode, DImode, },
    { DImode, VOIDmode, },
    { VOIDmode, VOIDmode, },
    { VOIDmode },
    { SFmode, SFmode, },
    { SFmode, SFmode, },
    { DFmode, DFmode, },
    { DFmode, DFmode, },
    { SFmode, SFmode, },
    { DFmode, DFmode, },
    { SImode, SImode, },
    { SImode, SImode, },
    { SImode, SImode, },
    { HImode, HImode, },
    { HImode, HImode, },
    { QImode, QImode, },
    { QImode, QImode, },
    { SImode, SImode, },
    { VOIDmode, VOIDmode, },
    { DImode, DImode, },
    { DImode, DImode, },
    { DImode, DImode, },
    { VOIDmode, VOIDmode, },
    { QImode, SImode, DImode, SImode, },
    { HImode, SImode, DImode, SImode, },
    { QImode, DImode, DImode, DImode, },
    { QImode, DImode, DImode, DImode, },
    { SImode, VOIDmode, DImode, SImode, SImode, },
    { DImode, QImode, DImode, DImode, DImode, },
    { DImode, HImode, DImode, DImode, DImode, },
    { QImode, QImode, },
    { HImode, HImode, },
    { QImode, QImode, TImode, },
    { HImode, HImode, TImode, },
    { QImode, QImode, TImode, },
    { HImode, HImode, TImode, },
    { QImode, QImode, SImode, },
    { HImode, HImode, SImode, },
    { QImode, QImode, SImode, SImode, },
    { HImode, HImode, SImode, SImode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { VOIDmode, VOIDmode, VOIDmode, VOIDmode, },
    { DImode, QImode, DImode, DImode, },
    { DImode, DImode, DImode, DImode, },
    { QImode, DImode, DImode, DImode, },
    { BLKmode, BLKmode, DImode, DImode, },
    { BLKmode, DImode, DImode, },
    { DImode, },
    { DImode, DImode, },
    { VOIDmode, VOIDmode, },
    { VOIDmode },
    { DImode, DImode, DImode, },
    { VOIDmode },
    { DImode, DImode, DImode, },
    { DImode, DImode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode, },
    { VOIDmode },
    { VOIDmode },
    { VOIDmode },
    { VOIDmode },
    { VOIDmode },
    { VOIDmode },
    { VOIDmode },
    { VOIDmode, },
  };

const char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =
  {
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0 },
    { 0, },
    { 0 },
    { 0 },
    { 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0 },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, },
    { 0, 0, },
    { 0, 0, },
    { 0 },
    { 0, 0, 0, },
    { 0 },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0, },
  };

extern int register_operand ();
extern int nonimmediate_operand ();
extern int reg_or_0_operand ();
extern int add_operand ();
extern int sext_add_operand ();
extern int reg_no_subreg_operand ();
extern int const_int_operand ();
extern int reg_not_elim_operand ();
extern int const48_operand ();
extern int some_operand ();
extern int reg_or_8bit_operand ();
extern int cint8_operand ();
extern int general_operand ();
extern int input_operand ();
extern int divmod_operator ();
extern int and_operand ();
extern int or_operand ();
extern int reg_or_6bit_operand ();
extern int address_operand ();
extern int mode_width_operand ();
extern int mul8_operand ();
extern int mode_mask_operand ();
extern int immediate_operand ();
extern int reg_or_fp0_operand ();
extern int memory_operand ();
extern int scratch_operand ();
extern int alpha_comparison_operator ();
extern int alpha_swapped_comparison_operator ();
extern int signed_comparison_operator ();
extern int fp0_operand ();
extern int comparison_operator ();
extern int call_operand ();
extern int any_memory_operand ();
extern int reg_or_cint_operand ();

int (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =
  {
    { register_operand, nonimmediate_operand, },
    { 0, 0, },
    { register_operand, register_operand, },
    { register_operand, reg_or_0_operand, add_operand, },
    { register_operand, reg_or_0_operand, add_operand, },
    { 0, 0, 0, },
    { register_operand, reg_or_0_operand, sext_add_operand, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, },
    { register_operand, reg_or_0_operand, add_operand, },
    { register_operand, reg_no_subreg_operand, const_int_operand, },
    { 0, 0, 0, },
    { register_operand, reg_not_elim_operand, const48_operand, sext_add_operand, },
    { register_operand, reg_not_elim_operand, const48_operand, sext_add_operand, },
    { 0, 0, 0, 0, 0, 0, 0, },
    { register_operand, reg_not_elim_operand, const48_operand, sext_add_operand, },
    { some_operand, some_operand, some_operand, some_operand, },
    { 0, 0, 0, 0, },
    { some_operand, some_operand, const48_operand, some_operand, some_operand, },
    { 0, 0, 0, 0, 0, },
    { some_operand, some_operand, const48_operand, some_operand, some_operand, },
    { 0, 0, 0, 0, 0, },
    { some_operand, some_operand, const48_operand, some_operand, some_operand, },
    { 0, 0, 0, 0, 0, },
    { register_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_not_elim_operand, const48_operand, reg_or_8bit_operand, },
    { register_operand, reg_not_elim_operand, const48_operand, reg_or_8bit_operand, },
    { register_operand, reg_not_elim_operand, const48_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, cint8_operand, },
    { general_operand, nonimmediate_operand, nonimmediate_operand, },
    { general_operand, nonimmediate_operand, nonimmediate_operand, },
    { general_operand, nonimmediate_operand, nonimmediate_operand, },
    { general_operand, nonimmediate_operand, nonimmediate_operand, },
    { general_operand, input_operand, input_operand, },
    { general_operand, input_operand, input_operand, },
    { general_operand, input_operand, input_operand, },
    { general_operand, input_operand, input_operand, },
    { 0, divmod_operator, },
    { 0, divmod_operator, },
    { register_operand, reg_or_0_operand, and_operand, },
    { 0, 0, 0, },
    { register_operand, register_operand, },
    { register_operand, nonimmediate_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, nonimmediate_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, nonimmediate_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, nonimmediate_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, reg_or_8bit_operand, reg_or_0_operand, },
    { register_operand, reg_or_0_operand, or_operand, },
    { register_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_8bit_operand, reg_or_0_operand, },
    { register_operand, reg_or_0_operand, or_operand, },
    { register_operand, register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, reg_or_0_operand, reg_or_6bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_6bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_6bit_operand, },
    { register_operand, some_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, some_operand, },
    { register_operand, some_operand, },
    { register_operand, some_operand, },
    { register_operand, some_operand, },
    { register_operand, address_operand, },
    { register_operand, address_operand, },
    { register_operand, reg_or_0_operand, mode_width_operand, mul8_operand, },
    { register_operand, reg_or_0_operand, mode_width_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, mode_mask_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, mul8_operand, },
    { register_operand, register_operand, mul8_operand, },
    { register_operand, register_operand, mul8_operand, },
    { register_operand, register_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, mul8_operand, immediate_operand, },
    { register_operand, register_operand, mode_width_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, mode_mask_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, mode_width_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { memory_operand, reg_or_fp0_operand, scratch_operand, scratch_operand, },
    { memory_operand, reg_or_fp0_operand, scratch_operand, },
    { reg_no_subreg_operand, reg_or_fp0_operand, },
    { reg_no_subreg_operand, reg_or_fp0_operand, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, },
    { memory_operand, reg_or_fp0_operand, scratch_operand, scratch_operand, },
    { memory_operand, reg_or_fp0_operand, scratch_operand, },
    { reg_no_subreg_operand, reg_or_fp0_operand, },
    { reg_no_subreg_operand, reg_or_fp0_operand, },
    { register_operand, reg_no_subreg_operand, },
    { register_operand, reg_no_subreg_operand, },
    { register_operand, reg_no_subreg_operand, },
    { register_operand, reg_no_subreg_operand, },
    { register_operand, nonimmediate_operand, },
    { register_operand, register_operand, },
    { register_operand, nonimmediate_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, alpha_swapped_comparison_operator, reg_or_8bit_operand, reg_or_0_operand, },
    { register_operand, reg_or_8bit_operand, signed_comparison_operator, reg_or_0_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_8bit_operand, signed_comparison_operator, reg_or_0_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_8bit_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_8bit_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { register_operand, register_operand, },
    { 0, 0, 0, },
    { 0, 0, },
    { 0, 0, 0, },
    { 0, 0, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { 0, 0, 0, 0, },
    { register_operand, register_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { 0, 0, 0, 0, },
    { register_operand, register_operand, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { 0, 0, 0, 0, },
    { register_operand, reg_or_0_operand, reg_or_8bit_operand, },
    { 0, 0, 0, 0, },
    { 0, signed_comparison_operator, reg_or_0_operand, },
    { 0, signed_comparison_operator, register_operand, },
    { 0, reg_or_0_operand, },
    { 0, reg_or_0_operand, },
    { 0, 0, 0, 0, 0, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, alpha_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, fp0_operand, signed_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, fp0_operand, signed_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, fp0_operand, signed_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, fp0_operand, signed_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, fp0_operand, signed_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, fp0_operand, signed_comparison_operator, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { register_operand, reg_or_fp0_operand, reg_or_fp0_operand, },
    { 0, signed_comparison_operator, reg_or_fp0_operand, fp0_operand, },
    { 0, signed_comparison_operator, reg_or_fp0_operand, fp0_operand, },
    { reg_or_fp0_operand, reg_or_fp0_operand, },
    { reg_or_0_operand, reg_or_8bit_operand, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { 0, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, },
    { register_operand, comparison_operator, reg_or_8bit_operand, reg_or_8bit_operand, },
    { register_operand, comparison_operator, reg_or_8bit_operand, reg_or_8bit_operand, },
    { register_operand, comparison_operator, reg_or_8bit_operand, reg_or_8bit_operand, },
    { register_operand, comparison_operator, reg_or_8bit_operand, reg_or_8bit_operand, },
    { 0, 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, },
    { 0, 0, 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { call_operand, 0, },
    { call_operand, 0, },
    { call_operand, 0, general_operand, },
    { register_operand, call_operand, 0, },
    { register_operand, call_operand, 0, },
    { register_operand, call_operand, 0, general_operand, },
    { 0, 0, 0, },
    { 0 },
    { 0, },
    { 0 },
    { 0 },
    { register_operand, },
    { register_operand, 0, },
    { register_operand, 0, scratch_operand, },
    { register_operand, 0, },
    { register_operand, 0, },
    { register_operand, 0, scratch_operand, },
    { register_operand, 0, },
    { register_operand, 0, },
    { 0 },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, general_operand, },
    { nonimmediate_operand, general_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { nonimmediate_operand, input_operand, },
    { general_operand, general_operand, },
    { 0, 0, },
    { general_operand, input_operand, },
    { general_operand, input_operand, },
    { general_operand, general_operand, },
    { 0, 0, },
    { register_operand, memory_operand, const_int_operand, register_operand, },
    { register_operand, memory_operand, const_int_operand, register_operand, },
    { register_operand, address_operand, register_operand, register_operand, },
    { register_operand, address_operand, register_operand, register_operand, },
    { memory_operand, register_operand, const_int_operand, register_operand, register_operand, },
    { address_operand, register_operand, register_operand, register_operand, register_operand, },
    { address_operand, register_operand, register_operand, register_operand, register_operand, },
    { general_operand, general_operand, },
    { general_operand, general_operand, },
    { register_operand, any_memory_operand, register_operand, },
    { register_operand, any_memory_operand, register_operand, },
    { any_memory_operand, register_operand, register_operand, },
    { any_memory_operand, register_operand, register_operand, },
    { register_operand, memory_operand, register_operand, },
    { register_operand, memory_operand, register_operand, },
    { memory_operand, register_operand, register_operand, register_operand, },
    { memory_operand, register_operand, register_operand, register_operand, },
    { 0, 0, 0, },
    { 0, 0, 0, },
    { 0, 0, 0, 0, },
    { 0, 0, 0, 0, },
    { register_operand, memory_operand, immediate_operand, immediate_operand, },
    { register_operand, general_operand, immediate_operand, immediate_operand, },
    { memory_operand, immediate_operand, immediate_operand, register_operand, },
    { general_operand, general_operand, immediate_operand, immediate_operand, },
    { general_operand, immediate_operand, immediate_operand, },
    { const_int_operand, },
    { register_operand, reg_or_cint_operand, },
    { register_operand, register_operand, },
    { 0 },
    { register_operand, register_operand, register_operand, },
    { 0 },
    { register_operand, register_operand, register_operand, },
    { register_operand, const_int_operand, },
    { register_operand, },
    { 0, },
    { 0, },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { 0 },
    { immediate_operand, },
  };

const int insn_n_alternatives[] =
  {
    3,
    0,
    1,
    0,
    4,
    0,
    2,
    0,
    0,
    4,
    1,
    0,
    2,
    2,
    0,
    2,
    1,
    0,
    1,
    0,
    1,
    0,
    1,
    0,
    1,
    1,
    1,
    0,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    3,
    0,
    1,
    2,
    1,
    0,
    2,
    1,
    0,
    2,
    1,
    0,
    2,
    1,
    0,
    1,
    1,
    2,
    1,
    1,
    2,
    1,
    0,
    1,
    2,
    1,
    1,
    0,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    1,
    1,
    1,
    1,
    0,
    0,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    1,
    3,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    4,
    4,
    2,
    2,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    1,
    0,
    0,
    1,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    0,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    2,
    2,
    2,
    2,
    2,
    2,
    0,
    0,
    0,
    0,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    3,
    3,
    2,
    3,
    3,
    2,
    0,
    0,
    0,
    0,
    0,
    1,
    0,
    1,
    0,
    0,
    1,
    1,
    1,
    0,
    6,
    8,
    6,
    8,
    0,
    0,
    8,
    10,
    9,
    3,
    5,
    3,
    5,
    0,
    0,
    9,
    11,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    0,
    1,
    0,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
  };
