Add diclaimer of copyright to _osname() manual page.

[unix-history] / gnu / usr.bin / cc / common / insn-output.c

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

#include "config.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 <stdio.h>
#include "output.h"

static char *
output_0 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[0]))
   return AS2 (test%L0,%0,%0);

 operands[1] = const0_rtx;
 return AS2 (cmp%L0,%1,%0);
}
}

static char *
output_2 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[0]))
   return AS2 (test%W0,%0,%0);

 operands[1] = const0_rtx;
 return AS2 (cmp%W0,%1,%0);
}
}

static char *
output_4 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[0]))
   return AS2 (test%B0,%0,%0);

 operands[1] = const0_rtx;
 return AS2 (cmp%B0,%1,%0);
}
}

static char *
output_6 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (! STACK_TOP_P (operands[0]))
   abort ();

 output_asm_insn ("ftst", operands);

 if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
   output_asm_insn (AS1 (fstp,%y0), operands);

 return (char *) output_fp_cc0_set (insn);
}
}

static char *
output_8 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (! STACK_TOP_P (operands[0]))
   abort ();

 output_asm_insn ("ftst", operands);

 if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
   output_asm_insn (AS1 (fstp,%y0), operands);

 return (char *) output_fp_cc0_set (insn);
}
}

static char *
output_10 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (CONSTANT_P (operands[0]) || GET_CODE (operands[1]) == MEM)
   {
     cc_status.flags |= CC_REVERSED;
     return AS2 (cmp%L0,%0,%1);
   }
 return AS2 (cmp%L0,%1,%0);
}
}

static char *
output_12 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (CONSTANT_P (operands[0]) || GET_CODE (operands[1]) == MEM)
   {
     cc_status.flags |= CC_REVERSED;
     return AS2 (cmp%W0,%0,%1);
   }
 return AS2 (cmp%W0,%1,%0);
}
}

static char *
output_14 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (CONSTANT_P (operands[0]) || GET_CODE (operands[1]) == MEM)
   {
     cc_status.flags |= CC_REVERSED;
     return AS2 (cmp%B0,%0,%1);
   }
 return AS2 (cmp%B0,%1,%0);
}
}

static char *
output_16 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_17 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_18 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_19 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_20 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_21 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_22 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_23 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_24 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_25 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_float_compare (insn, operands);
}

static char *
output_32 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 /* For small integers, we may actually use testb. */
 if (GET_CODE (operands[1]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))
     && (! REG_P (operands[0]) || QI_REG_P (operands[0])))
   {
     /* We may set the sign bit spuriously.  */

     if ((INTVAL (operands[1]) & ~0xff) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         return AS2 (test%B0,%1,%b0);
       }

     if ((INTVAL (operands[1]) & ~0xff00) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         operands[1] = GEN_INT (INTVAL (operands[1]) >> 8);

         if (QI_REG_P (operands[0]))
           return AS2 (test%B0,%1,%h0);
         else
           {
             operands[0] = adj_offsettable_operand (operands[0], 1);
             return AS2 (test%B0,%1,%b0);
           }
       }

     if (GET_CODE (operands[0]) == MEM
         && (INTVAL (operands[1]) & ~0xff0000) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         operands[1] = GEN_INT (INTVAL (operands[1]) >> 16);
         operands[0] = adj_offsettable_operand (operands[0], 2);
         return AS2 (test%B0,%1,%b0);
       }

     if (GET_CODE (operands[0]) == MEM
         && (INTVAL (operands[1]) & ~0xff000000) == 0)
       {
         operands[1] = GEN_INT ((INTVAL (operands[1]) >> 24) & 0xff);
         operands[0] = adj_offsettable_operand (operands[0], 3);
         return AS2 (test%B0,%1,%b0);
       }
   }

 if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
   return AS2 (test%L0,%1,%0);

 return AS2 (test%L1,%0,%1);
}
}

static char *
output_33 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[1]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))
     && (! REG_P (operands[0]) || QI_REG_P (operands[0])))
   {
     if ((INTVAL (operands[1]) & 0xff00) == 0)
       {
         /* ??? This might not be necessary. */
         if (INTVAL (operands[1]) & 0xffff0000)
           operands[1] = GEN_INT (INTVAL (operands[1]) & 0xff);

         /* We may set the sign bit spuriously.  */
         cc_status.flags |= CC_NOT_NEGATIVE;
         return AS2 (test%B0,%1,%b0);
       }

     if ((INTVAL (operands[1]) & 0xff) == 0)
       {
         operands[1] = GEN_INT ((INTVAL (operands[1]) >> 8) & 0xff);

         if (QI_REG_P (operands[0]))
           return AS2 (test%B0,%1,%h0);
         else
           {
             operands[0] = adj_offsettable_operand (operands[0], 1);
             return AS2 (test%B0,%1,%b0);
           }
       }
   }

 if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
   return AS2 (test%W0,%1,%0);

 return AS2 (test%W1,%0,%1);
}
}

static char *
output_34 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
   return AS2 (test%B0,%1,%0);

 return AS2 (test%B1,%0,%1);
}
}

static char *
output_38 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx link;
 if (operands[1] == const0_rtx && REG_P (operands[0]))
   return AS2 (xor%L0,%0,%0);

 if (operands[1] == const1_rtx
     && (link = find_reg_note (insn, REG_WAS_0, 0))
     /* Make sure the insn that stored the 0 is still present.  */
     && ! INSN_DELETED_P (XEXP (link, 0))
     && GET_CODE (XEXP (link, 0)) != NOTE
     /* Make sure cross jumping didn't happen here.  */
     && no_labels_between_p (XEXP (link, 0), insn)
     /* Make sure the reg hasn't been clobbered.  */
     && ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
   /* Fastest way to change a 0 to a 1.  */
   return AS1 (inc%L0,%0);

 return AS2 (mov%L0,%1,%0);
}
}

static char *
output_40 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx link;
 if (REG_P (operands[0]) && operands[1] == const0_rtx)
   return AS2 (xor%L0,%k0,%k0);

 if (REG_P (operands[0]) && operands[1] == const1_rtx 
     && (link = find_reg_note (insn, REG_WAS_0, 0))
     /* Make sure the insn that stored the 0 is still present.  */
     && ! INSN_DELETED_P (XEXP (link, 0))
     && GET_CODE (XEXP (link, 0)) != NOTE
     /* Make sure cross jumping didn't happen here.  */
     && no_labels_between_p (XEXP (link, 0), insn)
     /* Make sure the reg hasn't been clobbered.  */
     && ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
   /* Fastest way to change a 0 to a 1.  */
   return AS1 (inc%L0,%k0);

 if (REG_P (operands[0]))
   {
     if (REG_P (operands[1]))
       return AS2 (mov%L0,%k1,%k0);
     else if (CONSTANT_P (operands[1]))
       return AS2 (mov%L0,%1,%k0);
   }

 return AS2 (mov%W0,%1,%0);
}
}

static char *
output_41 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx link;
 if (operands[1] == const0_rtx && REG_P (operands[0]))
   return AS2 (xor%W0,%0,%0);

 if (operands[1] == const1_rtx
     && (link = find_reg_note (insn, REG_WAS_0, 0))
     /* Make sure the insn that stored the 0 is still present.  */
     && ! INSN_DELETED_P (XEXP (link, 0))
     && GET_CODE (XEXP (link, 0)) != NOTE
     /* Make sure cross jumping didn't happen here.  */
     && no_labels_between_p (XEXP (link, 0), insn)
     /* Make sure the reg hasn't been clobbered.  */
     && ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
   /* Fastest way to change a 0 to a 1.  */
   return AS1 (inc%W0,%0);

 return AS2 (mov%W0,%1,%0);
}
}

static char *
output_42 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 operands[1] = gen_rtx (REG, HImode, REGNO (operands[1]));
 return AS1 (push%W0,%1);
}
}

static char *
output_43 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx link;
 if (operands[1] == const0_rtx && REG_P (operands[0]))
   return AS2 (xor%B0,%0,%0);

 if (operands[1] == const1_rtx
     && (link = find_reg_note (insn, REG_WAS_0, 0))
     /* Make sure the insn that stored the 0 is still present.  */
     && ! INSN_DELETED_P (XEXP (link, 0))
     && GET_CODE (XEXP (link, 0)) != NOTE
     /* Make sure cross jumping didn't happen here.  */
     && no_labels_between_p (XEXP (link, 0), insn)
     /* Make sure the reg hasn't been clobbered.  */
     && ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
   /* Fastest way to change a 0 to a 1.  */
   return AS1 (inc%B0,%0);

 /* If mov%B0 isn't allowed for one of these regs, use mov%L0.  */
 if (NON_QI_REG_P (operands[0]) || NON_QI_REG_P (operands[1]))
   return (AS2 (mov%L0,%k1,%k0));

 return (AS2 (mov%B0,%1,%0));
}
}

static char *
output_44 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx link;
 if (operands[1] == const0_rtx && REG_P (operands[0]))
   return AS2 (xor%B0,%0,%0);

 if (operands[1] == const1_rtx
     && (link = find_reg_note (insn, REG_WAS_0, 0))
     /* Make sure the insn that stored the 0 is still present.  */
     && ! INSN_DELETED_P (XEXP (link, 0))
     && GET_CODE (XEXP (link, 0)) != NOTE
     /* Make sure cross jumping didn't happen here.  */
     && no_labels_between_p (XEXP (link, 0), insn)
     /* Make sure the reg hasn't been clobbered.  */
     && ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
   /* Fastest way to change a 0 to a 1.  */
   return AS1 (inc%B0,%0);

 /* If mov%B0 isn't allowed for one of these regs, use mov%W0.  */
 if (NON_QI_REG_P (operands[0]) || NON_QI_REG_P (operands[1]))
   {
     abort ();
     return (AS2 (mov%L0,%k1,%k0));
   }

 return AS2 (mov%B0,%1,%0);
}
}

static char *
output_45 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (STACK_REG_P (operands[1]))
   {
     rtx xops[3];

     if (! STACK_TOP_P (operands[1]))
       abort ();

     xops[0] = AT_SP (SFmode);
     xops[1] = GEN_INT (4);
     xops[2] = stack_pointer_rtx;

     output_asm_insn (AS2 (sub%L2,%1,%2), xops);

     if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
       output_asm_insn (AS1 (fstp%S0,%0), xops);
     else
       output_asm_insn (AS1 (fst%S0,%0), xops);
     RET;
   }
 return AS1 (push%L1,%1);
}
}

static char *
output_46 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;

 /* First handle a `pop' insn or a `fld %st(0)' */

 if (STACK_TOP_P (operands[0]) && STACK_TOP_P (operands[1]))
   {
     if (stack_top_dies)
       return AS1 (fstp,%y0);
     else
       return AS1 (fld,%y0);
   }

 /* Handle a transfer between the 387 and a 386 register */

 if (STACK_TOP_P (operands[0]) && NON_STACK_REG_P (operands[1]))
   {
     output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
     RET;
   }

 if (STACK_TOP_P (operands[1]) && NON_STACK_REG_P (operands[0]))
   {
     output_to_reg (operands[0], stack_top_dies);
     RET;
   }

 /* Handle other kinds of writes from the 387 */

 if (STACK_TOP_P (operands[1]))
   {
     if (stack_top_dies)
       return AS1 (fstp%z0,%y0);
     else
       return AS1 (fst%z0,%y0);
   }

 /* Handle other kinds of reads to the 387 */

 if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE)
   return (char *) output_move_const_single (operands);

 if (STACK_TOP_P (operands[0]))
   return AS1 (fld%z1,%y1);

 /* Handle all SFmode moves not involving the 387 */

 return (char *) singlemove_string (operands);
}
}

static char *
output_47 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (STACK_REG_P (operands[1]))
   {
     rtx xops[3];

     xops[0] = AT_SP (SFmode);
     xops[1] = GEN_INT (8);
     xops[2] = stack_pointer_rtx;

     output_asm_insn (AS2 (sub%L2,%1,%2), xops);

     if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
       output_asm_insn (AS1 (fstp%Q0,%0), xops);
     else
       output_asm_insn (AS1 (fst%Q0,%0), xops);

     RET;
   }
 else
   return (char *) output_move_double (operands);
}
}

static char *
output_48 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (STACK_TOP_P (operands[0]))
   return AS1 (fxch,%1);
 else
   return AS1 (fxch,%0);
}
}

static char *
output_49 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;

 /* First handle a `pop' insn or a `fld %st(0)' */

 if (STACK_TOP_P (operands[0]) && STACK_TOP_P (operands[1]))
   {
     if (stack_top_dies)
       return AS1 (fstp,%y0);
     else
       return AS1 (fld,%y0);
   }

 /* Handle a transfer between the 387 and a 386 register */

 if (STACK_TOP_P (operands[0]) && NON_STACK_REG_P (operands[1]))
   {
     output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
     RET;
   }

 if (STACK_TOP_P (operands[1]) && NON_STACK_REG_P (operands[0]))
   {
     output_to_reg (operands[0], stack_top_dies);
     RET;
   }

 /* Handle other kinds of writes from the 387 */

 if (STACK_TOP_P (operands[1]))
   {
     if (stack_top_dies)
       return AS1 (fstp%z0,%y0);
     else
       return AS1 (fst%z0,%y0);
   }

 /* Handle other kinds of reads to the 387 */

 if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE)
   return (char *) output_move_const_single (operands);

 if (STACK_TOP_P (operands[0]))
   return AS1 (fld%z1,%y1);

 /* Handle all DFmode moves not involving the 387 */

 return (char *) output_move_double (operands);
}
}

static char *
output_50 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 return (char *) output_move_double (operands);
}
}

static char *
output_51 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 return (char *) output_move_double (operands);
}
}

static char *
output_52 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if ((TARGET_486 || REGNO (operands[0]) == 0)
     && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1]))
   {
     rtx xops[2];
     xops[0] = operands[0];
     xops[1] = GEN_INT (0xffff);
     output_asm_insn (AS2 (and%L0,%1,%k0), xops);
     RET;
   }

#ifdef INTEL_SYNTAX
 return AS2 (movzx,%1,%0);
#else
 return AS2 (movz%W0%L0,%1,%0);
#endif
}
}

static char *
output_53 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if ((TARGET_486 || REGNO (operands[0]) == 0)
     && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1]))
   {
     rtx xops[2];
     xops[0] = operands[0];
     xops[1] = GEN_INT (0xff);
     output_asm_insn (AS2 (and%L0,%1,%k0), xops);
     RET;
   }

#ifdef INTEL_SYNTAX
 return AS2 (movzx,%1,%0);
#else
 return AS2 (movz%B0%W0,%1,%0);
#endif
}
}

static char *
output_54 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if ((TARGET_486 || REGNO (operands[0]) == 0)
     && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1]))
   {
     rtx xops[2];
     xops[0] = operands[0];
     xops[1] = GEN_INT (0xff);
     output_asm_insn (AS2 (and%L0,%1,%k0), xops);
     RET;
   }

#ifdef INTEL_SYNTAX
 return AS2 (movzx,%1,%0);
#else
 return AS2 (movz%B0%L0,%1,%0);
#endif
}
}

static char *
output_55 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
 return AS2 (xor%L0,%0,%0);
}
}

static char *
output_56 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REGNO (operands[0]) == 0)
   {
     /* This used to be cwtl, but that extends HI to SI somehow.  */
#ifdef INTEL_SYNTAX
     return "cdq";
#else
     return "cltd";
#endif
   }

 operands[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
 output_asm_insn (AS2 (mov%L0,%0,%1), operands);

 operands[0] = GEN_INT (31);
 return AS2 (sar%L1,%0,%1);
}
}

static char *
output_57 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REGNO (operands[0]) == 0
     && REG_P (operands[1]) && REGNO (operands[1]) == 0)
#ifdef INTEL_SYNTAX
   return "cwde";
#else
   return "cwtl";
#endif

#ifdef INTEL_SYNTAX
 return AS2 (movsx,%1,%0);
#else
 return AS2 (movs%W0%L0,%1,%0);
#endif
}
}

static char *
output_58 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REGNO (operands[0]) == 0
     && REG_P (operands[1]) && REGNO (operands[1]) == 0)
   return "cbtw";

#ifdef INTEL_SYNTAX
 return AS2 (movsx,%1,%0);
#else
 return AS2 (movs%B0%W0,%1,%0);
#endif
}
}

static char *
output_59 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
#ifdef INTEL_SYNTAX
 return AS2 (movsx,%1,%0);
#else
 return AS2 (movs%B0%L0,%1,%0);
#endif
}
}

static char *
output_60 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;

 if (NON_STACK_REG_P (operands[1]))
   {
     output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
     RET;
   }

 if (NON_STACK_REG_P (operands[0]))
   {
     output_to_reg (operands[0], stack_top_dies);
     RET;
   }

 if (STACK_TOP_P (operands[0]))
   return AS1 (fld%z1,%y1);

 if (GET_CODE (operands[0]) == MEM)
   {
     if (stack_top_dies)
       return AS1 (fstp%z0,%y0);
     else
       return AS1 (fst%z0,%y0);
   }

 abort ();
}
}

static char *
output_62 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;

 if (GET_CODE (operands[0]) == MEM)
   {
     if (stack_top_dies)
       return AS1 (fstp%z0,%0);
     else
       return AS1 (fst%z0,%0);
   }
 else if (STACK_TOP_P (operands[0]))
   {
     output_asm_insn (AS1 (fstp%z2,%y2), operands);
     return AS1 (fld%z2,%y2);
   }
 else
   abort ();
}
}

static char *
output_67 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_fix_trunc (insn, operands);
}

static char *
output_68 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_fix_trunc (insn, operands);
}

static char *
output_71 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_fix_trunc (insn, operands);
}

static char *
output_72 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_fix_trunc (insn, operands);
}

static char *
output_77 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (NON_STACK_REG_P (operands[1]))
   {
     output_op_from_reg (operands[1], AS1 (fild%z0,%1));
     RET;
   }
 else if (GET_CODE (operands[1]) == MEM)
   return AS1 (fild%z1,%1);
 else
   abort ();
}
}

static char *
output_78 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (NON_STACK_REG_P (operands[1]))
   {
     output_op_from_reg (operands[1], AS1 (fild%z0,%1));
     RET;
   }
 else if (GET_CODE (operands[1]) == MEM)
   return AS1 (fild%z1,%1);
 else
   abort ();
}
}

static char *
output_79 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (NON_STACK_REG_P (operands[1]))
   {
     output_op_from_reg (operands[1], AS1 (fild%z0,%1));
     RET;
   }
 else if (GET_CODE (operands[1]) == MEM)
   return AS1 (fild%z1,%1);
 else
   abort ();
}
}

static char *
output_80 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (NON_STACK_REG_P (operands[1]))
   {
     output_op_from_reg (operands[1], AS1 (fild%z0,%1));
     RET;
   }
 else if (GET_CODE (operands[1]) == MEM)
   return AS1 (fild%z1,%1);
 else
   abort ();
}
}

static char *
output_81 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx low[3], high[3];

 CC_STATUS_INIT;

 split_di (operands, 3, low, high);

 if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0)
   {
     output_asm_insn (AS2 (add%L0,%2,%0), low);
     output_asm_insn (AS2 (adc%L0,%2,%0), high);
   }
 else
   output_asm_insn (AS2 (add%L0,%2,%0), high);
 RET;
}
}

static char *
output_82 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[0]) && REGNO (operands[0]) != REGNO (operands[1]))
   {
     if (REG_P (operands[2]) && REGNO (operands[0]) == REGNO (operands[2]))
       return AS2 (add%L0,%1,%0);

     if (! TARGET_486 || ! REG_P (operands[2]))
       {
         CC_STATUS_INIT;

         if (operands[2] == stack_pointer_rtx)
           {
             rtx temp;

             temp = operands[1];
             operands[1] = operands[2];
             operands[2] = temp;
           }
         if (operands[2] != stack_pointer_rtx)
           {
             operands[1] = SET_SRC (PATTERN (insn));
             return AS2 (lea%L0,%a1,%0);
           }
       }

     output_asm_insn (AS2 (mov%L0,%1,%0), operands);
   }

 if (operands[2] == const1_rtx)
   return AS1 (inc%L0,%0);

 if (operands[2] == constm1_rtx)
   return AS1 (dec%L0,%0);

 return AS2 (add%L0,%2,%0);
}
}

static char *
output_83 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (operands[2] == const1_rtx)
   return AS1 (inc%W0,%0);

 if (operands[2] == constm1_rtx)
   return AS1 (dec%W0,%0);

 return AS2 (add%W0,%2,%0);
}
}

static char *
output_84 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (operands[2] == const1_rtx)
   return AS1 (inc%B0,%0);

 if (operands[2] == constm1_rtx)
   return AS1 (dec%B0,%0);

 return AS2 (add%B0,%2,%0);
}
}

static char *
output_85 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 CC_STATUS_INIT;
 /* Adding a constant to a register is faster with an add.  */
 /* ??? can this ever happen? */
 if (GET_CODE (operands[1]) == PLUS
     && GET_CODE (XEXP (operands[1], 1)) == CONST_INT
     && rtx_equal_p (operands[0], XEXP (operands[1], 0)))
   {
     operands[1] = XEXP (operands[1], 1);

     if (operands[1] == const1_rtx)
       return AS1 (inc%L0,%0);

     if (operands[1] == constm1_rtx)
       return AS1 (dec%L0,%0);

     return AS2 (add%L0,%1,%0);
   }
 return AS2 (lea%L0,%a1,%0);
}
}

static char *
output_88 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx low[3], high[3];

 CC_STATUS_INIT;

 split_di (operands, 3, low, high);

 if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0)
   {
     output_asm_insn (AS2 (sub%L0,%2,%0), low);
     output_asm_insn (AS2 (sbb%L0,%2,%0), high);
   }
 else
   output_asm_insn (AS2 (sub%L0,%2,%0), high);

 RET;
}
}

static char *
output_89 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (sub%L0,%2,%0);
}

static char *
output_90 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (sub%W0,%2,%0);
}

static char *
output_91 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (sub%B0,%2,%0);
}

static char *
output_94 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (imul%W0,%2,%0);
}

static char *
output_95 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[1]) == REG
     && REGNO (operands[1]) == REGNO (operands[0])
     && (GET_CODE (operands[2]) == MEM || GET_CODE (operands[2]) == REG))
   /* Assembler has weird restrictions.  */
   return AS2 (imul%W0,%2,%0);
 return AS3 (imul%W0,%2,%1,%0);
}
}

static char *
output_96 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (imul%L0,%2,%0);
}

static char *
output_97 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[1]) == REG
     && REGNO (operands[1]) == REGNO (operands[0])
     && (GET_CODE (operands[2]) == MEM || GET_CODE (operands[2]) == REG))
   /* Assembler has weird restrictions.  */
   return AS2 (imul%L0,%2,%0);
 return AS3 (imul%L0,%2,%1,%0);
}
}

static char *
output_105 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
#ifdef INTEL_SYNTAX
 output_asm_insn ("cdq", operands);
#else
 output_asm_insn ("cltd", operands);
#endif
 return AS1 (idiv%L0,%2);
}
}

static char *
output_107 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 output_asm_insn (AS2 (xor%L3,%3,%3), operands);
 return AS1 (div%L0,%2);
}
}

static char *
output_108 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 output_asm_insn (AS2 (xor%W0,%3,%3), operands);
 return AS1 (div%W0,%2);
}
}

static char *
output_109 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[2]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
   {
     if (INTVAL (operands[2]) == 0xffff && REG_P (operands[0])
         && (! REG_P (operands[1])
             || REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0)
         && (! TARGET_486 || ! rtx_equal_p (operands[0], operands[1])))
       {
         /* ??? tege: Should forget CC_STATUS only if we clobber a
            remembered operand.  Fix that later.  */
         CC_STATUS_INIT;
#ifdef INTEL_SYNTAX
         return AS2 (movzx,%w1,%0);
#else
         return AS2 (movz%W0%L0,%w1,%0);
#endif
       }

     if (INTVAL (operands[2]) == 0xff && REG_P (operands[0])
         && !(REG_P (operands[1]) && NON_QI_REG_P (operands[1]))
         && (! REG_P (operands[1])
             || REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0)
         && (! TARGET_486 || ! rtx_equal_p (operands[0], operands[1])))
       {
         /* ??? tege: Should forget CC_STATUS only if we clobber a
            remembered operand.  Fix that later.  */
         CC_STATUS_INIT;
#ifdef INTEL_SYNTAX
         return AS2 (movzx,%b1,%0);
#else
         return AS2 (movz%B0%L0,%b1,%0);
#endif
       }

     if (QI_REG_P (operands[0]) && ~(INTVAL (operands[2]) | 0xff) == 0)
       {
         CC_STATUS_INIT;

         if (INTVAL (operands[2]) == 0xffffff00)
           {
             operands[2] = const0_rtx;
             return AS2 (mov%B0,%2,%b0);
           }

         operands[2] = GEN_INT (INTVAL (operands[2]) & 0xff);
         return AS2 (and%B0,%2,%b0);
       }

     if (QI_REG_P (operands[0]) && ~(INTVAL (operands[2]) | 0xff00) == 0)
       {
         CC_STATUS_INIT;

         if (INTVAL (operands[2]) == 0xffff00ff)
           {
             operands[2] = const0_rtx;
             return AS2 (mov%B0,%2,%h0);
           }

         operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);
         return AS2 (and%B0,%2,%h0);
       }

     if (GET_CODE (operands[0]) == MEM && INTVAL (operands[2]) == 0xffff0000)
       {
         operands[2] = const0_rtx;
         return AS2 (mov%W0,%2,%w0);
       }
   }

 return AS2 (and%L0,%2,%0);
}
}

static char *
output_110 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[2]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
   {
     /* Can we ignore the upper byte? */
     if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
         && (INTVAL (operands[2]) & 0xff00) == 0xff00)
       {
         CC_STATUS_INIT;

         if ((INTVAL (operands[2]) & 0xff) == 0)
           {
             operands[2] = const0_rtx;
             return AS2 (mov%B0,%2,%b0);
           }

         operands[2] = GEN_INT (INTVAL (operands[2]) & 0xff);
         return AS2 (and%B0,%2,%b0);
       }

     /* Can we ignore the lower byte? */
     /* ??? what about offsettable memory references? */
     if (QI_REG_P (operands[0]) && (INTVAL (operands[2]) & 0xff) == 0xff)
       {
         CC_STATUS_INIT;

         if ((INTVAL (operands[2]) & 0xff00) == 0)
           {
             operands[2] = const0_rtx;
             return AS2 (mov%B0,%2,%h0);
           }

         operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);
         return AS2 (and%B0,%2,%h0);
       }
   }

 return AS2 (and%W0,%2,%0);
}
}

static char *
output_111 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (and%B0,%2,%0);
}

static char *
output_112 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[2]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
   {
     if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
         && (INTVAL (operands[2]) & ~0xff) == 0)
       {
         CC_STATUS_INIT;

         if (INTVAL (operands[2]) == 0xff)
           return AS2 (mov%B0,%2,%b0);

         return AS2 (or%B0,%2,%b0);
       }

     if (QI_REG_P (operands[0]) && (INTVAL (operands[2]) & ~0xff00) == 0)
       {
         CC_STATUS_INIT;
         operands[2] = GEN_INT (INTVAL (operands[2]) >> 8);

         if (INTVAL (operands[2]) == 0xff)
           return AS2 (mov%B0,%2,%h0);

         return AS2 (or%B0,%2,%h0);
       }
   }

 return AS2 (or%L0,%2,%0);
}
}

static char *
output_113 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[2]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
   {
     /* Can we ignore the upper byte? */
     if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
         && (INTVAL (operands[2]) & 0xff00) == 0)
       {
         CC_STATUS_INIT;
         if (INTVAL (operands[2]) & 0xffff0000)
           operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);

         if (INTVAL (operands[2]) == 0xff)
           return AS2 (mov%B0,%2,%b0);

         return AS2 (or%B0,%2,%b0);
       }

     /* Can we ignore the lower byte? */
     /* ??? what about offsettable memory references? */
     if (QI_REG_P (operands[0])
         && (INTVAL (operands[2]) & 0xff) == 0)
       {
         CC_STATUS_INIT;
         operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);

         if (INTVAL (operands[2]) == 0xff)
           return AS2 (mov%B0,%2,%h0);

         return AS2 (or%B0,%2,%h0);
       }
   }

 return AS2 (or%W0,%2,%0);
}
}

static char *
output_114 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (or%B0,%2,%0);
}

static char *
output_115 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[2]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
   {
     if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
         && (INTVAL (operands[2]) & ~0xff) == 0)
       {
         CC_STATUS_INIT;

         if (INTVAL (operands[2]) == 0xff)
           return AS1 (not%B0,%b0);

         return AS2 (xor%B0,%2,%b0);
       }

     if (QI_REG_P (operands[0]) && (INTVAL (operands[2]) & ~0xff00) == 0)
       {
         CC_STATUS_INIT;
         operands[2] = GEN_INT (INTVAL (operands[2]) >> 8);

         if (INTVAL (operands[2]) == 0xff)
           return AS1 (not%B0,%h0);

         return AS2 (xor%B0,%2,%h0);
       }
   }

 return AS2 (xor%L0,%2,%0);
}
}

static char *
output_116 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[2]) == CONST_INT
     && ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
   {
     /* Can we ignore the upper byte? */
     if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
         && (INTVAL (operands[2]) & 0xff00) == 0)
       {
         CC_STATUS_INIT;
         if (INTVAL (operands[2]) & 0xffff0000)
           operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);

         if (INTVAL (operands[2]) == 0xff)
           return AS1 (not%B0,%b0);

         return AS2 (xor%B0,%2,%b0);
       }

     /* Can we ignore the lower byte? */
     /* ??? what about offsettable memory references? */
     if (QI_REG_P (operands[0])
         && (INTVAL (operands[2]) & 0xff) == 0)
       {
         CC_STATUS_INIT;
         operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);

         if (INTVAL (operands[2]) == 0xff)
           return AS1 (not%B0,%h0);

         return AS2 (xor%B0,%2,%h0);
       }
   }

 return AS2 (xor%W0,%2,%0);
}
}

static char *
output_117 (operands, insn)
    rtx *operands;
    rtx insn;
{
return AS2 (xor%B0,%2,%0);
}

static char *
output_118 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[2], low[1], high[1];

 CC_STATUS_INIT;

 split_di (operands, 1, low, high);
 xops[0] = const0_rtx;
 xops[1] = high[0];

 output_asm_insn (AS1 (neg%L0,%0), low);
 output_asm_insn (AS2 (adc%L1,%0,%1), xops);
 output_asm_insn (AS1 (neg%L0,%0), high);
 RET;
}
}

static char *
output_141 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4], low[1], high[1];

 CC_STATUS_INIT;

 split_di (operands, 1, low, high);
 xops[0] = operands[2];
 xops[1] = const1_rtx;
 xops[2] = low[0];
 xops[3] = high[0];

 if (INTVAL (xops[0]) > 31)
   {
     output_asm_insn (AS2 (mov%L3,%2,%3), xops);       /* Fast shift by 32 */
     output_asm_insn (AS2 (xor%L2,%2,%2), xops);

     if (INTVAL (xops[0]) > 32)
       {
         xops[0] = GEN_INT (INTVAL (xops[0]) - 32);
         output_asm_insn (AS2 (sal%L3,%0,%3), xops); /* Remaining shift */
       }
   }
 else
   {
     output_asm_insn (AS3 (shld%L3,%0,%2,%3), xops);
     output_asm_insn (AS2 (sal%L2,%0,%2), xops);
   }
 RET;
}
}

static char *
output_142 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4], low[1], high[1];

 CC_STATUS_INIT;

 split_di (operands, 1, low, high);
 xops[0] = operands[2];
 xops[1] = const1_rtx;
 xops[2] = low[0];
 xops[3] = high[0];

 output_asm_insn (AS2 (ror%B0,%1,%0), xops);   /* shift count / 2 */

 output_asm_insn (AS3_SHIFT_DOUBLE (shld%L3,%0,%2,%3), xops);
 output_asm_insn (AS2 (sal%L2,%0,%2), xops);
 output_asm_insn (AS3_SHIFT_DOUBLE (shld%L3,%0,%2,%3), xops);
 output_asm_insn (AS2 (sal%L2,%0,%2), xops);

 xops[1] = GEN_INT (7);                        /* shift count & 1 */

 output_asm_insn (AS2 (shr%B0,%1,%0), xops);

 output_asm_insn (AS3_SHIFT_DOUBLE (shld%L3,%0,%2,%3), xops);
 output_asm_insn (AS2 (sal%L2,%0,%2), xops);

 RET;
}
}

static char *
output_143 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[0]) && REGNO (operands[0]) != REGNO (operands[1]))
   {
     if (TARGET_486 && INTVAL (operands[2]) == 1)
       {
         output_asm_insn (AS2 (mov%L0,%1,%0), operands);
         return AS2 (add%L0,%1,%0);
       }
     else
       {
         CC_STATUS_INIT;

         if (operands[1] == stack_pointer_rtx)
           {
             output_asm_insn (AS2 (mov%L0,%1,%0), operands);
             operands[1] = operands[0];
           }
         operands[1] = gen_rtx (MULT, SImode, operands[1],
                                GEN_INT (1 << INTVAL (operands[2])));
         return AS2 (lea%L0,%a1,%0);
       }
   }

 if (REG_P (operands[2]))
   return AS2 (sal%L0,%b2,%0);

 if (REG_P (operands[0]) && operands[2] == const1_rtx)
   return AS2 (add%L0,%0,%0);

 return AS2 (sal%L0,%2,%0);
}
}

static char *
output_144 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (sal%W0,%b2,%0);

 if (REG_P (operands[0]) && operands[2] == const1_rtx)
   return AS2 (add%W0,%0,%0);

 return AS2 (sal%W0,%2,%0);
}
}

static char *
output_145 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (sal%B0,%b2,%0);

 if (REG_P (operands[0]) && operands[2] == const1_rtx)
   return AS2 (add%B0,%0,%0);

 return AS2 (sal%B0,%2,%0);
}
}

static char *
output_147 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4], low[1], high[1];

 CC_STATUS_INIT;

 split_di (operands, 1, low, high);
 xops[0] = operands[2];
 xops[1] = const1_rtx;
 xops[2] = low[0];
 xops[3] = high[0];

 if (INTVAL (xops[0]) > 31)
   {
     xops[1] = GEN_INT (31);
     output_asm_insn (AS2 (mov%L2,%3,%2), xops);
     output_asm_insn (AS2 (sar%L3,%1,%3), xops);       /* shift by 32 */

     if (INTVAL (xops[0]) > 32)
       {
         xops[0] = GEN_INT (INTVAL (xops[0]) - 32);
         output_asm_insn (AS2 (sar%L2,%0,%2), xops); /* Remaining shift */
       }
   }
 else
   {
     output_asm_insn (AS3 (shrd%L2,%0,%3,%2), xops);
     output_asm_insn (AS2 (sar%L3,%0,%3), xops);
   }

 RET;
}
}

static char *
output_148 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4], low[1], high[1];

 CC_STATUS_INIT;

 split_di (operands, 1, low, high);
 xops[0] = operands[2];
 xops[1] = const1_rtx;
 xops[2] = low[0];
 xops[3] = high[0];

 output_asm_insn (AS2 (ror%B0,%1,%0), xops);   /* shift count / 2 */

 output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
 output_asm_insn (AS2 (sar%L3,%0,%3), xops);
 output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
 output_asm_insn (AS2 (sar%L3,%0,%3), xops);

 xops[1] = GEN_INT (7);                        /* shift count & 1 */

 output_asm_insn (AS2 (shr%B0,%1,%0), xops);

 output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
 output_asm_insn (AS2 (sar%L3,%0,%3), xops);

 RET;
}
}

static char *
output_149 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (sar%L0,%b2,%0);
 else
   return AS2 (sar%L0,%2,%0);
}
}

static char *
output_150 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (sar%W0,%b2,%0);
 else
   return AS2 (sar%W0,%2,%0);
}
}

static char *
output_151 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (sar%B0,%b2,%0);
 else
   return AS2 (sar%B0,%2,%0);
}
}

static char *
output_153 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4], low[1], high[1];

 CC_STATUS_INIT;

 split_di (operands, 1, low, high);
 xops[0] = operands[2];
 xops[1] = const1_rtx;
 xops[2] = low[0];
 xops[3] = high[0];

 if (INTVAL (xops[0]) > 31)
   {
     output_asm_insn (AS2 (mov%L2,%3,%2), xops);       /* Fast shift by 32 */
     output_asm_insn (AS2 (xor%L3,%3,%3), xops);

     if (INTVAL (xops[0]) > 32)
       {
         xops[0] = GEN_INT (INTVAL (xops[0]) - 32);
         output_asm_insn (AS2 (shr%L2,%0,%2), xops); /* Remaining shift */
       }
   }
 else
   {
     output_asm_insn (AS3 (shrd%L2,%0,%3,%2), xops);
     output_asm_insn (AS2 (shr%L3,%0,%3), xops);
   }

 RET;
}
}

static char *
output_154 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4], low[1], high[1];

 CC_STATUS_INIT;

 split_di (operands, 1, low, high);
 xops[0] = operands[2];
 xops[1] = const1_rtx;
 xops[2] = low[0];
 xops[3] = high[0];

 output_asm_insn (AS2 (ror%B0,%1,%0), xops);   /* shift count / 2 */

 output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
 output_asm_insn (AS2 (shr%L3,%0,%3), xops);
 output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
 output_asm_insn (AS2 (shr%L3,%0,%3), xops);

 xops[1] = GEN_INT (7);                        /* shift count & 1 */

 output_asm_insn (AS2 (shr%B0,%1,%0), xops);

 output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
 output_asm_insn (AS2 (shr%L3,%0,%3), xops);

 RET;
}
}

static char *
output_155 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (shr%L0,%b2,%0);
 else
   return AS2 (shr%L0,%2,%1);
}
}

static char *
output_156 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (shr%W0,%b2,%0);
 else
   return AS2 (shr%W0,%2,%0);
}
}

static char *
output_157 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (shr%B0,%b2,%0);
 else
   return AS2 (shr%B0,%2,%0);
}
}

static char *
output_158 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (rol%L0,%b2,%0);
 else
   return AS2 (rol%L0,%2,%0);
}
}

static char *
output_159 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (rol%W0,%b2,%0);
 else
   return AS2 (rol%W0,%2,%0);
}
}

static char *
output_160 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (rol%B0,%b2,%0);
 else
   return AS2 (rol%B0,%2,%0);
}
}

static char *
output_161 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (ror%L0,%b2,%0);
 else
   return AS2 (ror%L0,%2,%0);
}
}

static char *
output_162 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (ror%W0,%b2,%0);
 else
   return AS2 (ror%W0,%2,%0);
}
}

static char *
output_163 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (REG_P (operands[2]))
   return AS2 (ror%B0,%b2,%0);
 else
   return AS2 (ror%B0,%2,%0);
}
}

static char *
output_164 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 CC_STATUS_INIT;

 if (INTVAL (operands[3]) == 1)
   return AS2 (bts%L0,%2,%0);
 else
   return AS2 (btr%L0,%2,%0);
}
}

static char *
output_165 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 CC_STATUS_INIT;

 return AS2 (btc%L0,%1,%0);
}
}

static char *
output_166 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 CC_STATUS_INIT;

 return AS2 (btc%L0,%2,%0);
}
}

static char *
output_167 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 cc_status.flags |= CC_Z_IN_NOT_C;
 return AS2 (bt%L0,%1,%0);
}
}

static char *
output_168 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 unsigned int mask;

 mask = ((1 << INTVAL (operands[1])) - 1) << INTVAL (operands[2]);
 operands[1] = GEN_INT (mask);

 if (QI_REG_P (operands[0]))
   {
     if ((mask & ~0xff) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         return AS2 (test%B0,%1,%b0);
       }

     if ((mask & ~0xff00) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         operands[1] = GEN_INT (mask >> 8);
         return AS2 (test%B0,%1,%h0);
       }
   }

 return AS2 (test%L0,%1,%0);
}
}

static char *
output_169 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 unsigned int mask;

 mask = ((1 << INTVAL (operands[1])) - 1) << INTVAL (operands[2]);
 operands[1] = GEN_INT (mask);

 if (! REG_P (operands[0]) || QI_REG_P (operands[0]))
   {
     if ((mask & ~0xff) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         return AS2 (test%B0,%1,%b0);
       }

     if ((mask & ~0xff00) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         operands[1] = GEN_INT (mask >> 8);

         if (QI_REG_P (operands[0]))
           return AS2 (test%B0,%1,%h0);
         else
           {
             operands[0] = adj_offsettable_operand (operands[0], 1);
             return AS2 (test%B0,%1,%b0);
           }
       }

     if (GET_CODE (operands[0]) == MEM && (mask & ~0xff0000) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         operands[1] = GEN_INT (mask >> 16);
         operands[0] = adj_offsettable_operand (operands[0], 2);
         return AS2 (test%B0,%1,%b0);
       }

     if (GET_CODE (operands[0]) == MEM && (mask & ~0xff000000) == 0)
       {
         cc_status.flags |= CC_NOT_NEGATIVE;
         operands[1] = GEN_INT (mask >> 24);
         operands[0] = adj_offsettable_operand (operands[0], 3);
         return AS2 (test%B0,%1,%b0);
       }
   }

 if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
   return AS2 (test%L0,%1,%0);

 return AS2 (test%L1,%0,%1);
}
}

static char *
output_171 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (cc_prev_status.flags & CC_Z_IN_NOT_C)
   return AS1 (setnb,%0);
 else
   return AS1 (sete,%0);
}
}

static char *
output_173 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (cc_prev_status.flags & CC_Z_IN_NOT_C)
   return AS1 (setb,%0);
 else
   return AS1 (setne,%0);
}

}

static char *
output_175 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (sete,%0);

 OUTPUT_JUMP ("setg %0", "seta %0", NULL_PTR);
}
}

static char *
output_177 (operands, insn)
    rtx *operands;
    rtx insn;
{
return "seta %0"; 
}

static char *
output_179 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (sete,%0);

 OUTPUT_JUMP ("setl %0", "setb %0", "sets %0");
}
}

static char *
output_181 (operands, insn)
    rtx *operands;
    rtx insn;
{
return "setb %0"; 
}

static char *
output_183 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (sete,%0);

 OUTPUT_JUMP ("setge %0", "setae %0", "setns %0");
}
}

static char *
output_185 (operands, insn)
    rtx *operands;
    rtx insn;
{
return "setae %0"; 
}

static char *
output_187 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (setb,%0);

 OUTPUT_JUMP ("setle %0", "setbe %0", NULL_PTR);
}
}

static char *
output_189 (operands, insn)
    rtx *operands;
    rtx insn;
{
return "setbe %0"; 
}

static char *
output_191 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (cc_prev_status.flags & CC_Z_IN_NOT_C)
   return "jnc %l0";
 else
   return "je %l0";
}
}

static char *
output_193 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (cc_prev_status.flags & CC_Z_IN_NOT_C)
   return "jc %l0";
 else
   return "jne %l0";
}
}

static char *
output_195 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (je,%l0);

 OUTPUT_JUMP ("jg %l0", "ja %l0", NULL_PTR);
}
}

static char *
output_199 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (je,%l0);

 OUTPUT_JUMP ("jl %l0", "jb %l0", "js %l0");
}
}

static char *
output_203 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (je,%l0);

 OUTPUT_JUMP ("jge %l0", "jae %l0", "jns %l0");
}
}

static char *
output_207 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (jb,%l0);

 OUTPUT_JUMP ("jle %l0", "jbe %l0", NULL_PTR);
}
}

static char *
output_210 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (cc_prev_status.flags & CC_Z_IN_NOT_C)
   return "jc %l0";
 else
   return "jne %l0";
}
}

static char *
output_211 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (cc_prev_status.flags & CC_Z_IN_NOT_C)
   return "jnc %l0";
 else
   return "je %l0";
}
}

static char *
output_212 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (jne,%l0);

 OUTPUT_JUMP ("jle %l0", "jbe %l0", NULL_PTR);
}
}

static char *
output_214 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (jne,%l0);

 OUTPUT_JUMP ("jge %l0", "jae %l0", "jns %l0");
}
}

static char *
output_216 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (jne,%l0);

 OUTPUT_JUMP ("jl %l0", "jb %l0", "js %l0");
}
}

static char *
output_218 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
   return AS1 (jae,%l0);

 OUTPUT_JUMP ("jg %l0", "ja %l0", NULL_PTR);
}
}

static char *
output_221 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 CC_STATUS_INIT;

 return AS1 (jmp,%*%0);
}
}

static char *
output_223 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4];

 xops[0] = operands[0];
 xops[1] = operands[1];
 xops[2] = operands[2];
 xops[3] = pic_offset_table_rtx;

 output_asm_insn (AS2 (mov%L2,%3,%2), xops);
 output_asm_insn ("sub%L2 %l1@GOTOFF(%3,%0,4),%2", xops);
 output_asm_insn (AS1 (jmp,%*%2), xops);
 ASM_OUTPUT_ALIGN_CODE (asm_out_file);
 RET;
}
}

static char *
output_224 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 CC_STATUS_INIT;

 return AS1 (jmp,%*%0);
}
}

static char *
output_226 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[0]) == MEM
     && ! CONSTANT_ADDRESS_P (XEXP (operands[0], 0)))
   {
     operands[0] = XEXP (operands[0], 0);
     return AS1 (call,%*%0);
   }
 else
   return AS1 (call,%P0);
}
}

static char *
output_229 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[0]) == MEM
     && ! CONSTANT_ADDRESS_P (XEXP (operands[0], 0)))
   {
     operands[0] = XEXP (operands[0], 0);
     return AS1 (call,%*%0);
   }
 else
   return AS1 (call,%P0);
}
}

static char *
output_232 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[1]) == MEM
     && ! CONSTANT_ADDRESS_P (XEXP (operands[1], 0)))
   {
     operands[1] = XEXP (operands[1], 0);
     output_asm_insn (AS1 (call,%*%1), operands);
   }
 else
   output_asm_insn (AS1 (call,%P1), operands);

 RET;
}
}

static char *
output_235 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 if (GET_CODE (operands[1]) == MEM
     && ! CONSTANT_ADDRESS_P (XEXP (operands[1], 0)))
   {
     operands[1] = XEXP (operands[1], 0);
     output_asm_insn (AS1 (call,%*%1), operands);
   }
 else
   output_asm_insn (AS1 (call,%P1), operands);

 RET;
}
}

static char *
output_238 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx addr = operands[1];

 if (GET_CODE (operands[0]) == MEM
     && ! CONSTANT_ADDRESS_P (XEXP (operands[0], 0)))
   {
     operands[0] = XEXP (operands[0], 0);
     output_asm_insn (AS1 (call,%*%0), operands);
   }
 else
   output_asm_insn (AS1 (call,%P0), operands);

 operands[2] = gen_rtx (REG, SImode, 0);
 output_asm_insn (AS2 (mov%L2,%2,%1), operands);

 operands[2] = gen_rtx (REG, SImode, 1);
 operands[1] = adj_offsettable_operand (addr, 4);
 output_asm_insn (AS2 (mov%L2,%2,%1), operands);

 operands[1] = adj_offsettable_operand (addr, 8);
 return AS1 (fnsave,%1);
}
}

static char *
output_239 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx addr = operands[1];

 output_asm_insn (AS1 (call,%P0), operands);

 operands[2] = gen_rtx (REG, SImode, 0);
 output_asm_insn (AS2 (mov%L2,%2,%1), operands);

 operands[2] = gen_rtx (REG, SImode, 1);
 operands[1] = adj_offsettable_operand (addr, 4);
 output_asm_insn (AS2 (mov%L2,%2,%1), operands);

 operands[1] = adj_offsettable_operand (addr, 8);
 return AS1 (fnsave,%1);
}
}

static char *
output_242 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 function_epilogue (asm_out_file, get_frame_size ());
 RET;
}
}

static char *
output_245 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[2];

 output_asm_insn ("cld", operands);
 if (GET_CODE (operands[2]) == CONST_INT)
   {
     if (INTVAL (operands[2]) & ~0x03)
       {
         xops[0] = GEN_INT ((INTVAL (operands[2]) >> 2) & 0x3fffffff);
         xops[1] = operands[4];

         output_asm_insn (AS2 (mov%L1,%0,%1), xops);
#ifdef INTEL_SYNTAX
         output_asm_insn ("rep movsd", xops);
#else
         output_asm_insn ("rep\n\tmovsl", xops);
#endif
       }
     if (INTVAL (operands[2]) & 0x02)
       output_asm_insn ("movsw", operands);
     if (INTVAL (operands[2]) & 0x01)
       output_asm_insn ("movsb", operands);
   }
 else
   abort ();
 RET;
}
}

static char *
output_247 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[4], label;

 label = gen_label_rtx ();

 output_asm_insn ("cld", operands);
 output_asm_insn (AS2 (xor%L0,%0,%0), operands);
 output_asm_insn ("repz\n\tcmps%B2", operands);
 output_asm_insn ("je %l0", &label);

 xops[0] = operands[0];
 xops[1] = gen_rtx (MEM, QImode,
                    gen_rtx (PLUS, SImode, operands[1], constm1_rtx));
 xops[2] = gen_rtx (MEM, QImode,
                    gen_rtx (PLUS, SImode, operands[2], constm1_rtx));
 xops[3] = operands[3];

 output_asm_insn (AS2 (movz%B1%L0,%1,%0), xops);
 output_asm_insn (AS2 (movz%B2%L3,%2,%3), xops);

 output_asm_insn (AS2 (sub%L0,%3,%0), xops);
 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (label));
 RET;
}
}

static char *
output_248 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[2];

 cc_status.flags |= CC_NOT_SIGNED;

 xops[0] = gen_rtx (REG, QImode, 0);
 xops[1] = CONST0_RTX (QImode);

 output_asm_insn ("cld", operands);
 output_asm_insn (AS2 (test%B0,%1,%0), xops);
 return "repz\n\tcmps%B2";
}
}

static char *
output_250 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[2];

 xops[0] = const1_rtx;
 xops[1] = operands[1];
 output_asm_insn (AS2 (bsf%L1,%1,%0), operands);
 output_asm_insn (AS2 (cmp%L1,%0,%1), xops);
 output_asm_insn (AS2 (sbb%L0,%2,%2), operands);
 output_asm_insn (AS2 (or%L0,%2,%0), operands);
 return "";
}
}

static char *
output_252 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[2];

 xops[0] = const1_rtx;
 xops[1] = operands[1];
 output_asm_insn (AS2 (bsf%W1,%1,%0), operands);
 output_asm_insn (AS2 (cmp%W1,%0,%1), xops);
 output_asm_insn (AS2 (sbb%W0,%2,%2), operands);
 output_asm_insn (AS2 (or%W0,%2,%0), operands);
 return "";
}
}

static char *
output_253 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_254 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_255 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_256 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_257 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_258 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_259 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_260 (operands, insn)
    rtx *operands;
    rtx insn;
{
return (char *) output_387_binary_op (insn, operands);
}

static char *
output_262 (operands, insn)
    rtx *operands;
    rtx insn;
{

{
 rtx xops[2];

 xops[0] = operands[0];
 xops[1] = constm1_rtx;
 output_asm_insn ("cld", operands);
 output_asm_insn (AS2 (mov%L0,%1,%0), xops);
 return "repnz\n\tscas%B2";
}
}

char * const insn_template[] =
 {
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   "push%L0 %1",
   "push%L0 %1",
   0,
   0,
   "push%W0 %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,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   "mul%B0 %2",
   0,
   0,
   "idiv%B0 %2",
   "div%B0 %2",
   0,
   0,
   0,
   "cwtd\n\tidiv%W0 %2",
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   "neg%L0 %0",
   "neg%W0 %0",
   "neg%B0 %0",
   "fchs",
   "fchs",
   "fchs",
   "fabs",
   "fabs",
   "fabs",
   "fsqrt",
   "fsqrt",
   "fsqrt",
   "fsin",
   "fsin",
   "fsin",
   "fcos",
   "fcos",
   "fcos",
   "not%L0 %0",
   "not%W0 %0",
   "not%B0 %0",
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   "ja %l0",
   0,
   0,
   0,
   "jb %l0",
   0,
   0,
   0,
   "jae %l0",
   0,
   0,
   0,
   "jbe %l0",
   0,
   0,
   0,
   "jbe %l0",
   0,
   "jae %l0",
   0,
   "jb %l0",
   0,
   "ja %l0",
   "jmp %l0",
   0,
   0,
   0,
   0,
   0,
   0,
   "call %P0",
   0,
   0,
   "call %P0",
   0,
   0,
   "call %P1",
   0,
   0,
   "call %P1",
   0,
   0,
   0,
   0,
   "frstor %0",
   0,
   "nop",
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
 };

char *(*const insn_outfun[])() =
 {
   output_0,
   0,
   output_2,
   0,
   output_4,
   0,
   output_6,
   0,
   output_8,
   0,
   output_10,
   0,
   output_12,
   0,
   output_14,
   0,
   output_16,
   output_17,
   output_18,
   output_19,
   output_20,
   output_21,
   output_22,
   output_23,
   output_24,
   output_25,
   0,
   0,
   0,
   0,
   0,
   0,
   output_32,
   output_33,
   output_34,
   0,
   0,
   0,
   output_38,
   0,
   output_40,
   output_41,
   output_42,
   output_43,
   output_44,
   output_45,
   output_46,
   output_47,
   output_48,
   output_49,
   output_50,
   output_51,
   output_52,
   output_53,
   output_54,
   output_55,
   output_56,
   output_57,
   output_58,
   output_59,
   output_60,
   0,
   output_62,
   0,
   0,
   0,
   0,
   output_67,
   output_68,
   0,
   0,
   output_71,
   output_72,
   0,
   0,
   0,
   0,
   output_77,
   output_78,
   output_79,
   output_80,
   output_81,
   output_82,
   output_83,
   output_84,
   output_85,
   0,
   0,
   output_88,
   output_89,
   output_90,
   output_91,
   0,
   0,
   output_94,
   output_95,
   output_96,
   output_97,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   output_105,
   0,
   output_107,
   output_108,
   output_109,
   output_110,
   output_111,
   output_112,
   output_113,
   output_114,
   output_115,
   output_116,
   output_117,
   output_118,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   output_141,
   output_142,
   output_143,
   output_144,
   output_145,
   0,
   output_147,
   output_148,
   output_149,
   output_150,
   output_151,
   0,
   output_153,
   output_154,
   output_155,
   output_156,
   output_157,
   output_158,
   output_159,
   output_160,
   output_161,
   output_162,
   output_163,
   output_164,
   output_165,
   output_166,
   output_167,
   output_168,
   output_169,
   0,
   output_171,
   0,
   output_173,
   0,
   output_175,
   0,
   output_177,
   0,
   output_179,
   0,
   output_181,
   0,
   output_183,
   0,
   output_185,
   0,
   output_187,
   0,
   output_189,
   0,
   output_191,
   0,
   output_193,
   0,
   output_195,
   0,
   0,
   0,
   output_199,
   0,
   0,
   0,
   output_203,
   0,
   0,
   0,
   output_207,
   0,
   0,
   output_210,
   output_211,
   output_212,
   0,
   output_214,
   0,
   output_216,
   0,
   output_218,
   0,
   0,
   output_221,
   0,
   output_223,
   output_224,
   0,
   output_226,
   0,
   0,
   output_229,
   0,
   0,
   output_232,
   0,
   0,
   output_235,
   0,
   0,
   output_238,
   output_239,
   0,
   0,
   output_242,
   0,
   0,
   output_245,
   0,
   output_247,
   output_248,
   0,
   output_250,
   0,
   output_252,
   output_253,
   output_254,
   output_255,
   output_256,
   output_257,
   output_258,
   output_259,
   output_260,
   0,
   output_262,
 };

rtx (*const insn_gen_function[]) () =
 {
   gen_tstsi_1,
   gen_tstsi,
   gen_tsthi_1,
   gen_tsthi,
   gen_tstqi_1,
   gen_tstqi,
   gen_tstsf_cc,
   gen_tstsf,
   gen_tstdf_cc,
   gen_tstdf,
   gen_cmpsi_1,
   gen_cmpsi,
   gen_cmphi_1,
   gen_cmphi,
   gen_cmpqi_1,
   gen_cmpqi,
   0,
   0,
   0,
   0,
   0,
   0,
   gen_cmpsf_cc_1,
   0,
   0,
   0,
   gen_cmpdf,
   gen_cmpsf,
   gen_cmpdf_cc,
   gen_cmpdf_ccfpeq,
   gen_cmpsf_cc,
   gen_cmpsf_ccfpeq,
   0,
   0,
   0,
   0,
   0,
   gen_movsi,
   0,
   0,
   gen_movhi,
   gen_movstricthi,
   0,
   gen_movqi,
   gen_movstrictqi,
   0,
   gen_movsf,
   0,
   gen_swapdf,
   gen_movdf,
   0,
   gen_movdi,
   gen_zero_extendhisi2,
   gen_zero_extendqihi2,
   gen_zero_extendqisi2,
   gen_zero_extendsidi2,
   gen_extendsidi2,
   gen_extendhisi2,
   gen_extendqihi2,
   gen_extendqisi2,
   gen_extendsfdf2,
   gen_truncdfsf2,
   0,
   gen_fixuns_truncdfsi2,
   gen_fixuns_truncsfsi2,
   gen_fix_truncdfdi2,
   gen_fix_truncsfdi2,
   0,
   0,
   gen_fix_truncdfsi2,
   gen_fix_truncsfsi2,
   0,
   0,
   gen_floatsisf2,
   gen_floatdisf2,
   gen_floatsidf2,
   gen_floatdidf2,
   0,
   0,
   0,
   0,
   gen_adddi3,
   gen_addsi3,
   gen_addhi3,
   gen_addqi3,
   0,
   gen_adddf3,
   gen_addsf3,
   gen_subdi3,
   gen_subsi3,
   gen_subhi3,
   gen_subqi3,
   gen_subdf3,
   gen_subsf3,
   0,
   gen_mulhi3,
   0,
   gen_mulsi3,
   0,
   gen_muldf3,
   gen_mulsf3,
   gen_divqi3,
   gen_udivqi3,
   gen_divdf3,
   gen_divsf3,
   gen_divmodsi4,
   gen_divmodhi4,
   gen_udivmodsi4,
   gen_udivmodhi4,
   gen_andsi3,
   gen_andhi3,
   gen_andqi3,
   gen_iorsi3,
   gen_iorhi3,
   gen_iorqi3,
   gen_xorsi3,
   gen_xorhi3,
   gen_xorqi3,
   gen_negdi2,
   gen_negsi2,
   gen_neghi2,
   gen_negqi2,
   gen_negsf2,
   gen_negdf2,
   0,
   gen_abssf2,
   gen_absdf2,
   0,
   gen_sqrtsf2,
   gen_sqrtdf2,
   0,
   gen_sindf2,
   gen_sinsf2,
   0,
   gen_cosdf2,
   gen_cossf2,
   0,
   gen_one_cmplsi2,
   gen_one_cmplhi2,
   gen_one_cmplqi2,
   gen_ashldi3,
   gen_ashldi3_const_int,
   gen_ashldi3_non_const_int,
   gen_ashlsi3,
   gen_ashlhi3,
   gen_ashlqi3,
   gen_ashrdi3,
   gen_ashrdi3_const_int,
   gen_ashrdi3_non_const_int,
   gen_ashrsi3,
   gen_ashrhi3,
   gen_ashrqi3,
   gen_lshrdi3,
   gen_lshrdi3_const_int,
   gen_lshrdi3_non_const_int,
   gen_lshrsi3,
   gen_lshrhi3,
   gen_lshrqi3,
   gen_rotlsi3,
   gen_rotlhi3,
   gen_rotlqi3,
   gen_rotrsi3,
   gen_rotrhi3,
   gen_rotrqi3,
   0,
   0,
   0,
   0,
   0,
   0,
   gen_seq,
   0,
   gen_sne,
   0,
   gen_sgt,
   0,
   gen_sgtu,
   0,
   gen_slt,
   0,
   gen_sltu,
   0,
   gen_sge,
   0,
   gen_sgeu,
   0,
   gen_sle,
   0,
   gen_sleu,
   0,
   gen_beq,
   0,
   gen_bne,
   0,
   gen_bgt,
   0,
   gen_bgtu,
   0,
   gen_blt,
   0,
   gen_bltu,
   0,
   gen_bge,
   0,
   gen_bgeu,
   0,
   gen_ble,
   0,
   gen_bleu,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   gen_jump,
   gen_indirect_jump,
   gen_casesi,
   0,
   gen_tablejump,
   gen_call_pop,
   0,
   0,
   gen_call,
   0,
   0,
   gen_call_value_pop,
   0,
   0,
   gen_call_value,
   0,
   0,
   gen_untyped_call,
   0,
   0,
   gen_untyped_return,
   gen_update_return,
   gen_return,
   gen_nop,
   gen_movstrsi,
   0,
   gen_cmpstrsi,
   0,
   0,
   gen_ffssi2,
   0,
   gen_ffshi2,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   gen_strlensi,
   0,
 };

char *insn_name[] =
 {
   "tstsi_1",
   "tstsi",
   "tsthi_1",
   "tsthi",
   "tstqi_1",
   "tstqi",
   "tstsf_cc",
   "tstsf",
   "tstdf_cc",
   "tstdf",
   "cmpsi_1",
   "cmpsi",
   "cmphi_1",
   "cmphi",
   "cmpqi_1",
   "cmpqi",
   "cmpqi+1",
   "cmpqi+2",
   "cmpqi+3",
   "cmpsf_cc_1-3",
   "cmpsf_cc_1-2",
   "cmpsf_cc_1-1",
   "cmpsf_cc_1",
   "cmpsf_cc_1+1",
   "cmpsf_cc_1+2",
   "cmpdf-1",
   "cmpdf",
   "cmpsf",
   "cmpdf_cc",
   "cmpdf_ccfpeq",
   "cmpsf_cc",
   "cmpsf_ccfpeq",
   "cmpsf_ccfpeq+1",
   "cmpsf_ccfpeq+2",
   "cmpsf_ccfpeq+3",
   "movsi-2",
   "movsi-1",
   "movsi",
   "movsi+1",
   "movhi-1",
   "movhi",
   "movstricthi",
   "movstricthi+1",
   "movqi",
   "movstrictqi",
   "movstrictqi+1",
   "movsf",
   "movsf+1",
   "swapdf",
   "movdf",
   "movdf+1",
   "movdi",
   "zero_extendhisi2",
   "zero_extendqihi2",
   "zero_extendqisi2",
   "zero_extendsidi2",
   "extendsidi2",
   "extendhisi2",
   "extendqihi2",
   "extendqisi2",
   "extendsfdf2",
   "truncdfsf2",
   "truncdfsf2+1",
   "fixuns_truncdfsi2",
   "fixuns_truncsfsi2",
   "fix_truncdfdi2",
   "fix_truncsfdi2",
   "fix_truncsfdi2+1",
   "fix_truncdfsi2-1",
   "fix_truncdfsi2",
   "fix_truncsfsi2",
   "fix_truncsfsi2+1",
   "floatsisf2-1",
   "floatsisf2",
   "floatdisf2",
   "floatsidf2",
   "floatdidf2",
   "floatdidf2+1",
   "floatdidf2+2",
   "adddi3-2",
   "adddi3-1",
   "adddi3",
   "addsi3",
   "addhi3",
   "addqi3",
   "addqi3+1",
   "adddf3",
   "addsf3",
   "subdi3",
   "subsi3",
   "subhi3",
   "subqi3",
   "subdf3",
   "subsf3",
   "subsf3+1",
   "mulhi3",
   "mulhi3+1",
   "mulsi3",
   "mulsi3+1",
   "muldf3",
   "mulsf3",
   "divqi3",
   "udivqi3",
   "divdf3",
   "divsf3",
   "divmodsi4",
   "divmodhi4",
   "udivmodsi4",
   "udivmodhi4",
   "andsi3",
   "andhi3",
   "andqi3",
   "iorsi3",
   "iorhi3",
   "iorqi3",
   "xorsi3",
   "xorhi3",
   "xorqi3",
   "negdi2",
   "negsi2",
   "neghi2",
   "negqi2",
   "negsf2",
   "negdf2",
   "negdf2+1",
   "abssf2",
   "absdf2",
   "absdf2+1",
   "sqrtsf2",
   "sqrtdf2",
   "sqrtdf2+1",
   "sindf2",
   "sinsf2",
   "sinsf2+1",
   "cosdf2",
   "cossf2",
   "cossf2+1",
   "one_cmplsi2",
   "one_cmplhi2",
   "one_cmplqi2",
   "ashldi3",
   "ashldi3_const_int",
   "ashldi3_non_const_int",
   "ashlsi3",
   "ashlhi3",
   "ashlqi3",
   "ashrdi3",
   "ashrdi3_const_int",
   "ashrdi3_non_const_int",
   "ashrsi3",
   "ashrhi3",
   "ashrqi3",
   "lshrdi3",
   "lshrdi3_const_int",
   "lshrdi3_non_const_int",
   "lshrsi3",
   "lshrhi3",
   "lshrqi3",
   "rotlsi3",
   "rotlhi3",
   "rotlqi3",
   "rotrsi3",
   "rotrhi3",
   "rotrqi3",
   "rotrqi3+1",
   "rotrqi3+2",
   "rotrqi3+3",
   "seq-3",
   "seq-2",
   "seq-1",
   "seq",
   "seq+1",
   "sne",
   "sne+1",
   "sgt",
   "sgt+1",
   "sgtu",
   "sgtu+1",
   "slt",
   "slt+1",
   "sltu",
   "sltu+1",
   "sge",
   "sge+1",
   "sgeu",
   "sgeu+1",
   "sle",
   "sle+1",
   "sleu",
   "sleu+1",
   "beq",
   "beq+1",
   "bne",
   "bne+1",
   "bgt",
   "bgt+1",
   "bgtu",
   "bgtu+1",
   "blt",
   "blt+1",
   "bltu",
   "bltu+1",
   "bge",
   "bge+1",
   "bgeu",
   "bgeu+1",
   "ble",
   "ble+1",
   "bleu",
   "bleu+1",
   "bleu+2",
   "bleu+3",
   "bleu+4",
   "bleu+5",
   "bleu+6",
   "jump-5",
   "jump-4",
   "jump-3",
   "jump-2",
   "jump-1",
   "jump",
   "indirect_jump",
   "casesi",
   "casesi+1",
   "tablejump",
   "call_pop",
   "call_pop+1",
   "call-1",
   "call",
   "call+1",
   "call_value_pop-1",
   "call_value_pop",
   "call_value_pop+1",
   "call_value-1",
   "call_value",
   "call_value+1",
   "untyped_call-1",
   "untyped_call",
   "untyped_call+1",
   "untyped_return-1",
   "untyped_return",
   "update_return",
   "return",
   "nop",
   "movstrsi",
   "movstrsi+1",
   "cmpstrsi",
   "cmpstrsi+1",
   "ffssi2-1",
   "ffssi2",
   "ffssi2+1",
   "ffshi2",
   "ffshi2+1",
   "ffshi2+2",
   "ffshi2+3",
   "ffshi2+4",
   "ffshi2+5",
   "strlensi-4",
   "strlensi-3",
   "strlensi-2",
   "strlensi-1",
   "strlensi",
   "strlensi+1",
 };
char **insn_name_ptr = insn_name;

const int insn_n_operands[] =
 {
   1,
   1,
   1,
   1,
   1,
   1,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   4,
   4,
   4,
   4,
   4,
   3,
   4,
   4,
   4,
   3,
   2,
   2,
   3,
   3,
   3,
   3,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   3,
   8,
   8,
   6,
   6,
   5,
   5,
   5,
   5,
   5,
   5,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   3,
   3,
   3,
   3,
   2,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   4,
   4,
   4,
   4,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   3,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   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,
   3,
   3,
   3,
   3,
   4,
   3,
   3,
   2,
   3,
   3,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   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,
   1,
   7,
   3,
   1,
   4,
   4,
   4,
   2,
   2,
   2,
   5,
   5,
   5,
   3,
   3,
   3,
   3,
   3,
   3,
   2,
   1,
   0,
   0,
   5,
   5,
   5,
   5,
   4,
   3,
   3,
   3,
   3,
   4,
   4,
   4,
   4,
   4,
   4,
   4,
   4,
   4,
   4,
 };

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,
   2,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   1,
   0,
   7,
   7,
   5,
   5,
   1,
   1,
   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,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   2,
   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,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   1,
   0,
   0,
   0,
   0,
   0,
   1,
   0,
   0,
   0,
   0,
   0,
   1,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   3,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   2,
   2,
   3,
   3,
   3,
   2,
   0,
   2,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   0,
   5,
   1,
 };

char *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =
 {
   { "rm", },
   { "", },
   { "rm", },
   { "", },
   { "qm", },
   { "", },
   { "f", "=a", },
   { "", "", },
   { "f", "=a", },
   { "", "", },
   { "mr,r", "ri,mr", },
   { "", "", },
   { "mr,r", "ri,mr", },
   { "", "", },
   { "q,mq", "qm,nq", },
   { "", "", },
   { "f,fm", "fm,f", "", "=a,a", },
   { "f", "rm", "", "=a", },
   { "rm", "f", "", "=a", },
   { "f", "fm", "", "=a", },
   { "fm", "f", "", "=a", },
   { "f", "f", "=a", },
   { "f,fm", "fm,f", "", "=a,a", },
   { "f", "rm", "", "=a", },
   { "rm", "f", "", "=a", },
   { "f", "f", "=a", },
   { "", "", },
   { "", "", },
   { "", "", "", },
   { "", "", "", },
   { "", "", "", },
   { "", "", "", },
   { "%ro", "ri", },
   { "%ro", "ri", },
   { "%qm", "qi", },
   { "=<", "g", },
   { "=<", "ri", },
   { "", "", },
   { "=g,r", "ri,m", },
   { "=<", "g", },
   { "=g,r", "ri,m", },
   { "+g,r", "ri,m", },
   { "=<", "q", },
   { "=q,*r,qm", "*g,q,qn", },
   { "+q,qm", "*g,qn", },
   { "=<,<", "gF,f", },
   { "=*rfm,*rf,f,!*rm", "*rf,*rfm,fG,fF", },
   { "=<,<", "gF,f", },
   { "f", "f", },
   { "=*rfm,*rf,f,!*rm", "*rf,*rfm,fG,fF", },
   { "=<", "roiF", },
   { "=r,rm", "m,riF", },
   { "=r", "rm", },
   { "=r", "qm", },
   { "=r", "qm", },
   { "=r", "0", },
   { "=r", "0", },
   { "=r", "rm", },
   { "=r", "qm", },
   { "=r", "qm", },
   { "=fm,f", "f,fm", },
   { "", "", },
   { "=f,m", "0,f", "m,m", },
   { "", "", "", "", "", "", "", "", },
   { "", "", "", "", "", "", "", "", },
   { "", "", "", "", "", "", },
   { "", "", "", "", "", "", },
   { "=rm", "f", "m", "m", "=&q", },
   { "=rm", "f", "m", "m", "=&q", },
   { "", "", "", "", "", },
   { "", "", "", "", "", },
   { "=rm", "f", "m", "m", "=&q", },
   { "=rm", "f", "m", "m", "=&q", },
   { "", "", },
   { "", "", },
   { "", "", },
   { "", "", },
   { "=f", "rm", },
   { "=f", "rm", },
   { "=f", "rm", },
   { "=f", "rm", },
   { "=&r,ro", "%0,0", "o,riF", },
   { "=?r,rm,r", "%r,0,0", "ri,ri,rm", },
   { "=rm,r", "%0,0", "ri,rm", },
   { "=qm,q", "%0,0", "qn,qmn", },
   { "=r", "p", },
   { "", "", "", },
   { "", "", "", },
   { "=&r,ro", "0,0", "o,riF", },
   { "=rm,r", "0,0", "ri,rm", },
   { "=rm,r", "0,0", "ri,rm", },
   { "=qm,q", "0,0", "qn,qmn", },
   { "", "", "", },
   { "", "", "", },
   { "=r", "%0", "r", },
   { "=r,r", "%0,rm", "g,i", },
   { "=r", "%0", "r", },
   { "=r,r", "%0,rm", "g,i", },
   { "=a", "%0", "qm", },
   { "", "", "", },
   { "", "", "", },
   { "=a", "0", "qm", },
   { "=a", "0", "qm", },
   { "", "", "", },
   { "", "", "", },
   { "=a", "0", "rm", "=&d", },
   { "=a", "0", "rm", "=&d", },
   { "=a", "0", "rm", "=&d", },
   { "=a", "0", "rm", "=&d", },
   { "=r,r,rm,r", "%rm,qm,0,0", "L,K,ri,rm", },
   { "=rm,r", "%0,0", "ri,rm", },
   { "=qm,q", "%0,0", "qn,qmn", },
   { "=rm,r", "%0,0", "ri,rm", },
   { "=rm,r", "%0,0", "ri,rm", },
   { "=qm,q", "%0,0", "qn,qmn", },
   { "=rm,r", "%0,0", "ri,rm", },
   { "=rm,r", "%0,0", "ri,rm", },
   { "=qm,q", "%0,0", "qn,qm", },
   { "=&ro", "0", },
   { "=rm", "0", },
   { "=rm", "0", },
   { "=qm", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=f", "0", },
   { "=rm", "0", },
   { "=rm", "0", },
   { "=qm", "0", },
   { "", "", "", },
   { "=&r", "0", "J", },
   { "=&r", "0", "c", },
   { "=r,rm", "r,0", "M,cI", },
   { "=rm", "0", "cI", },
   { "=qm", "0", "cI", },
   { "", "", "", },
   { "=&r", "0", "J", },
   { "=&r", "0", "c", },
   { "=rm", "0", "cI", },
   { "=rm", "0", "cI", },
   { "=qm", "0", "cI", },
   { "", "", "", },
   { "=&r", "0", "J", },
   { "=&r", "0", "c", },
   { "=rm", "0", "cI", },
   { "=rm", "0", "cI", },
   { "=qm", "0", "cI", },
   { "=rm", "0", "cI", },
   { "=rm", "0", "cI", },
   { "=qm", "0", "cI", },
   { "=rm", "0", "cI", },
   { "=rm", "0", "cI", },
   { "=qm", "0", "cI", },
   { "+rm", "", "r", "n", },
   { "=rm", "r", "0", },
   { "=rm", "0", "r", },
   { "r", "r", },
   { "r", "n", "n", },
   { "rm", "n", "n", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { "", },
   { "=q", },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { "rm", },
   { "", "", "", "", "", "", "", },
   { "r", "", "=&r", },
   { "rm", },
   { "", "", "", "", },
   { "m", "g", "", "i", },
   { "", "g", "", "i", },
   { "", "", },
   { "m", "g", },
   { "", "g", },
   { "", "", "", "", "", },
   { "=rf", "m", "g", "", "i", },
   { "=rf", "", "g", "", "i", },
   { "", "", "", },
   { "=rf", "m", "g", },
   { "=rf", "", "g", },
   { "", "", "", },
   { "m", "o", "", },
   { "", "o", "", },
   { "", "", },
   { "m", },
   { 0 },
   { 0 },
   { "", "", "", "", "", },
   { "D", "S", "n", "i", "=&c", },
   { "", "", "", "", "", },
   { "=&r", "S", "D", "c", "i", },
   { "S", "D", "c", "i", },
   { "", "", "", },
   { "=&r", "rm", "=r", },
   { "", "", "", },
   { "=&r", "rm", "=r", },
   { "=f,f", "0,fm", "fm,0", "", },
   { "=f", "rm", "0", "", },
   { "=f,f", "fm,0", "0,f", "", },
   { "=f", "0", "rm", "", },
   { "=f,f", "0,f", "fm,0", "", },
   { "=f,f", "0,fm", "fm,0", "", },
   { "=f", "rm", "0", "", },
   { "=f", "0", "rm", "", },
   { "", "", "", "", },
   { "=&c", "D", "a", "i", },
 };

const enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =
 {
   { SImode, },
   { SImode, },
   { HImode, },
   { HImode, },
   { QImode, },
   { QImode, },
   { SFmode, HImode, },
   { SFmode, HImode, },
   { DFmode, HImode, },
   { DFmode, HImode, },
   { SImode, SImode, },
   { SImode, SImode, },
   { HImode, HImode, },
   { HImode, HImode, },
   { QImode, QImode, },
   { QImode, QImode, },
   { DFmode, DFmode, VOIDmode, HImode, },
   { DFmode, SImode, VOIDmode, HImode, },
   { SImode, DFmode, VOIDmode, HImode, },
   { DFmode, SFmode, VOIDmode, HImode, },
   { SFmode, DFmode, VOIDmode, HImode, },
   { DFmode, DFmode, HImode, },
   { SFmode, SFmode, VOIDmode, HImode, },
   { SFmode, SImode, VOIDmode, HImode, },
   { SImode, SFmode, VOIDmode, HImode, },
   { SFmode, SFmode, HImode, },
   { DFmode, DFmode, },
   { SFmode, SFmode, },
   { DFmode, DFmode, HImode, },
   { DFmode, DFmode, HImode, },
   { SFmode, SFmode, HImode, },
   { SFmode, SFmode, HImode, },
   { SImode, SImode, },
   { HImode, HImode, },
   { QImode, QImode, },
   { SImode, SImode, },
   { SImode, SImode, },
   { SImode, SImode, },
   { SImode, SImode, },
   { HImode, HImode, },
   { HImode, HImode, },
   { HImode, HImode, },
   { QImode, QImode, },
   { QImode, QImode, },
   { QImode, QImode, },
   { SFmode, SFmode, },
   { SFmode, SFmode, },
   { DFmode, DFmode, },
   { DFmode, DFmode, },
   { DFmode, DFmode, },
   { DImode, DImode, },
   { DImode, DImode, },
   { SImode, HImode, },
   { HImode, QImode, },
   { SImode, QImode, },
   { DImode, SImode, },
   { DImode, SImode, },
   { SImode, HImode, },
   { HImode, QImode, },
   { SImode, QImode, },
   { DFmode, SFmode, },
   { SFmode, DFmode, },
   { SFmode, DFmode, SFmode, },
   { SImode, DFmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
   { SImode, SFmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
   { DImode, DFmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
   { DImode, SFmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
   { DImode, DFmode, SImode, SImode, SImode, },
   { DImode, SFmode, SImode, SImode, SImode, },
   { SImode, DFmode, VOIDmode, VOIDmode, SImode, },
   { SImode, SFmode, VOIDmode, VOIDmode, SImode, },
   { SImode, DFmode, SImode, SImode, SImode, },
   { SImode, SFmode, SImode, SImode, SImode, },
   { SFmode, SImode, },
   { SFmode, DImode, },
   { DFmode, SImode, },
   { DFmode, DImode, },
   { DFmode, DImode, },
   { SFmode, DImode, },
   { DFmode, SImode, },
   { SFmode, SImode, },
   { DImode, DImode, DImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { SImode, QImode, },
   { DFmode, DFmode, DFmode, },
   { SFmode, SFmode, SFmode, },
   { DImode, DImode, DImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { DFmode, DFmode, DFmode, },
   { SFmode, SFmode, SFmode, },
   { HImode, HImode, HImode, },
   { HImode, HImode, HImode, },
   { SImode, SImode, SImode, },
   { SImode, SImode, SImode, },
   { HImode, QImode, QImode, },
   { DFmode, DFmode, DFmode, },
   { SFmode, SFmode, SFmode, },
   { QImode, HImode, QImode, },
   { QImode, HImode, QImode, },
   { DFmode, DFmode, DFmode, },
   { SFmode, SFmode, SFmode, },
   { SImode, SImode, SImode, SImode, },
   { HImode, HImode, HImode, HImode, },
   { SImode, SImode, SImode, SImode, },
   { HImode, HImode, HImode, HImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { DImode, DImode, },
   { SImode, SImode, },
   { HImode, HImode, },
   { QImode, QImode, },
   { SFmode, SFmode, },
   { DFmode, DFmode, },
   { DFmode, SFmode, },
   { SFmode, SFmode, },
   { DFmode, DFmode, },
   { DFmode, SFmode, },
   { SFmode, SFmode, },
   { DFmode, DFmode, },
   { DFmode, SFmode, },
   { DFmode, DFmode, },
   { SFmode, SFmode, },
   { DFmode, SFmode, },
   { DFmode, DFmode, },
   { SFmode, SFmode, },
   { DFmode, SFmode, },
   { SImode, SImode, },
   { HImode, HImode, },
   { QImode, QImode, },
   { DImode, DImode, QImode, },
   { DImode, DImode, QImode, },
   { DImode, DImode, QImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { DImode, DImode, QImode, },
   { DImode, DImode, QImode, },
   { DImode, DImode, QImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { DImode, DImode, QImode, },
   { DImode, DImode, QImode, },
   { DImode, DImode, QImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { QImode, QImode, QImode, },
   { SImode, VOIDmode, SImode, SImode, },
   { SImode, SImode, SImode, },
   { SImode, SImode, SImode, },
   { SImode, SImode, },
   { SImode, SImode, SImode, },
   { QImode, SImode, SImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { QImode, },
   { 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 },
   { VOIDmode },
   { VOIDmode },
   { SImode, },
   { SImode, SImode, SImode, VOIDmode, VOIDmode, VOIDmode, SImode, },
   { SImode, VOIDmode, SImode, },
   { SImode, },
   { QImode, SImode, VOIDmode, SImode, },
   { QImode, SImode, VOIDmode, SImode, },
   { SImode, SImode, VOIDmode, SImode, },
   { QImode, SImode, },
   { QImode, SImode, },
   { SImode, SImode, },
   { VOIDmode, QImode, SImode, VOIDmode, SImode, },
   { VOIDmode, QImode, SImode, VOIDmode, SImode, },
   { VOIDmode, SImode, SImode, VOIDmode, SImode, },
   { VOIDmode, QImode, SImode, },
   { VOIDmode, QImode, SImode, },
   { VOIDmode, SImode, SImode, },
   { QImode, BLKmode, VOIDmode, },
   { QImode, DImode, VOIDmode, },
   { SImode, DImode, VOIDmode, },
   { BLKmode, VOIDmode, },
   { SImode, },
   { VOIDmode },
   { VOIDmode },
   { BLKmode, BLKmode, SImode, SImode, SImode, },
   { SImode, SImode, SImode, SImode, SImode, },
   { SImode, BLKmode, BLKmode, SImode, SImode, },
   { SImode, SImode, SImode, SImode, SImode, },
   { SImode, SImode, SImode, SImode, },
   { SImode, SImode, SImode, },
   { SImode, SImode, SImode, },
   { HImode, HImode, HImode, },
   { HImode, HImode, HImode, },
   { DFmode, DFmode, DFmode, DFmode, },
   { DFmode, SImode, DFmode, DFmode, },
   { DFmode, SFmode, DFmode, DFmode, },
   { DFmode, DFmode, SImode, DFmode, },
   { DFmode, DFmode, SFmode, DFmode, },
   { SFmode, SFmode, SFmode, SFmode, },
   { SFmode, SImode, SFmode, SFmode, },
   { SFmode, SFmode, SImode, SFmode, },
   { SImode, BLKmode, QImode, SImode, },
   { SImode, SImode, QImode, SImode, },
 };

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, },
   { 1, 0, },
   { 0, 0, },
   { 0, 0, },
   { 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, 0, 0, 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0, },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0 },
   { 0, },
   { 0, 0, 0, 0, 0, 0, 0, },
   { 0, 0, 0, },
   { 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, },
   { 0, },
   { 0 },
   { 0 },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 0, 0, 0, 0, },
   { 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 nonimmediate_operand ();
extern int register_operand ();
extern int scratch_operand ();
extern int general_operand ();
extern int VOIDmode_compare_op ();
extern int push_operand ();
extern int memory_operand ();
extern int address_operand ();
extern int nonmemory_operand ();
extern int const_int_operand ();
extern int indirect_operand ();
extern int immediate_operand ();
extern int call_insn_operand ();
extern int symbolic_operand ();
extern int binary_387_op ();

int (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =
 {
   { nonimmediate_operand, },
   { nonimmediate_operand, },
   { nonimmediate_operand, },
   { nonimmediate_operand, },
   { nonimmediate_operand, },
   { nonimmediate_operand, },
   { register_operand, scratch_operand, },
   { register_operand, scratch_operand, },
   { register_operand, scratch_operand, },
   { register_operand, scratch_operand, },
   { nonimmediate_operand, general_operand, },
   { nonimmediate_operand, general_operand, },
   { nonimmediate_operand, general_operand, },
   { nonimmediate_operand, general_operand, },
   { nonimmediate_operand, general_operand, },
   { nonimmediate_operand, general_operand, },
   { nonimmediate_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
   { register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
   { nonimmediate_operand, register_operand, VOIDmode_compare_op, scratch_operand, },
   { register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
   { nonimmediate_operand, register_operand, VOIDmode_compare_op, scratch_operand, },
   { register_operand, register_operand, scratch_operand, },
   { nonimmediate_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
   { register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
   { nonimmediate_operand, register_operand, VOIDmode_compare_op, scratch_operand, },
   { register_operand, register_operand, scratch_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, register_operand, scratch_operand, },
   { register_operand, register_operand, scratch_operand, },
   { register_operand, register_operand, scratch_operand, },
   { register_operand, register_operand, scratch_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { push_operand, general_operand, },
   { push_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { push_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { push_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { push_operand, general_operand, },
   { general_operand, general_operand, },
   { push_operand, general_operand, },
   { register_operand, register_operand, },
   { general_operand, general_operand, },
   { push_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, nonimmediate_operand, },
   { general_operand, nonimmediate_operand, },
   { general_operand, nonimmediate_operand, },
   { register_operand, register_operand, },
   { register_operand, register_operand, },
   { general_operand, nonimmediate_operand, },
   { general_operand, nonimmediate_operand, },
   { general_operand, nonimmediate_operand, },
   { general_operand, general_operand, },
   { nonimmediate_operand, register_operand, },
   { nonimmediate_operand, register_operand, memory_operand, },
   { general_operand, register_operand, 0, 0, 0, 0, 0, scratch_operand, },
   { general_operand, register_operand, 0, 0, 0, 0, 0, scratch_operand, },
   { general_operand, register_operand, 0, 0, 0, scratch_operand, },
   { general_operand, register_operand, 0, 0, 0, scratch_operand, },
   { general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
   { general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
   { general_operand, register_operand, 0, 0, scratch_operand, },
   { general_operand, register_operand, 0, 0, scratch_operand, },
   { general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
   { general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { register_operand, address_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, nonimmediate_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, },
   { register_operand, register_operand, general_operand, register_operand, },
   { register_operand, register_operand, general_operand, register_operand, },
   { register_operand, register_operand, general_operand, register_operand, },
   { register_operand, register_operand, general_operand, register_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, register_operand, },
   { register_operand, register_operand, },
   { register_operand, register_operand, },
   { register_operand, register_operand, },
   { register_operand, register_operand, },
   { register_operand, register_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { general_operand, general_operand, },
   { register_operand, register_operand, nonmemory_operand, },
   { register_operand, register_operand, const_int_operand, },
   { register_operand, register_operand, register_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { register_operand, register_operand, nonmemory_operand, },
   { register_operand, register_operand, const_int_operand, },
   { register_operand, register_operand, register_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { register_operand, register_operand, nonmemory_operand, },
   { register_operand, register_operand, const_int_operand, },
   { register_operand, register_operand, register_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, general_operand, nonmemory_operand, },
   { general_operand, 0, general_operand, const_int_operand, },
   { general_operand, general_operand, general_operand, },
   { general_operand, general_operand, general_operand, },
   { register_operand, general_operand, },
   { register_operand, const_int_operand, const_int_operand, },
   { general_operand, const_int_operand, const_int_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_operand, },
   { register_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 },
   { general_operand, },
   { general_operand, general_operand, general_operand, 0, 0, 0, scratch_operand, },
   { register_operand, 0, scratch_operand, },
   { general_operand, },
   { indirect_operand, general_operand, 0, immediate_operand, },
   { call_insn_operand, general_operand, 0, immediate_operand, },
   { symbolic_operand, general_operand, 0, immediate_operand, },
   { indirect_operand, general_operand, },
   { call_insn_operand, general_operand, },
   { symbolic_operand, general_operand, },
   { 0, indirect_operand, general_operand, 0, immediate_operand, },
   { 0, call_insn_operand, general_operand, 0, immediate_operand, },
   { 0, symbolic_operand, general_operand, 0, immediate_operand, },
   { 0, indirect_operand, general_operand, },
   { 0, call_insn_operand, general_operand, },
   { 0, symbolic_operand, general_operand, },
   { indirect_operand, memory_operand, 0, },
   { call_insn_operand, memory_operand, 0, },
   { symbolic_operand, memory_operand, 0, },
   { memory_operand, 0, },
   { memory_operand, },
   { 0 },
   { 0 },
   { memory_operand, memory_operand, const_int_operand, const_int_operand, scratch_operand, },
   { address_operand, address_operand, const_int_operand, immediate_operand, scratch_operand, },
   { general_operand, general_operand, general_operand, general_operand, immediate_operand, },
   { general_operand, address_operand, address_operand, register_operand, immediate_operand, },
   { address_operand, address_operand, register_operand, immediate_operand, },
   { general_operand, general_operand, scratch_operand, },
   { register_operand, general_operand, scratch_operand, },
   { general_operand, general_operand, scratch_operand, },
   { register_operand, general_operand, scratch_operand, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, binary_387_op, },
   { register_operand, general_operand, general_operand, binary_387_op, },
   { register_operand, general_operand, general_operand, binary_387_op, },
   { register_operand, general_operand, general_operand, binary_387_op, },
   { register_operand, general_operand, general_operand, binary_387_op, },
   { register_operand, nonimmediate_operand, nonimmediate_operand, binary_387_op, },
   { register_operand, general_operand, general_operand, binary_387_op, },
   { register_operand, general_operand, general_operand, binary_387_op, },
   { register_operand, general_operand, register_operand, immediate_operand, },
   { register_operand, address_operand, register_operand, immediate_operand, },
 };

const int insn_n_alternatives[] =
 {
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   2,
   0,
   2,
   0,
   2,
   0,
   2,
   1,
   1,
   1,
   1,
   1,
   2,
   1,
   1,
   1,
   0,
   0,
   0,
   0,
   0,
   0,
   1,
   1,
   1,
   1,
   1,
   0,
   2,
   1,
   2,
   2,
   1,
   3,
   2,
   2,
   4,
   2,
   1,
   4,
   1,
   2,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   2,
   0,
   2,
   0,
   0,
   0,
   0,
   1,
   1,
   0,
   0,
   1,
   1,
   0,
   0,
   0,
   0,
   1,
   1,
   1,
   1,
   2,
   3,
   2,
   2,
   1,
   0,
   0,
   2,
   2,
   2,
   2,
   0,
   0,
   1,
   2,
   1,
   2,
   1,
   0,
   0,
   1,
   1,
   0,
   0,
   1,
   1,
   1,
   1,
   4,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   2,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   0,
   1,
   1,
   2,
   1,
   1,
   0,
   1,
   1,
   1,
   1,
   1,
   0,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   1,
   0,
   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,
   1,
   0,
   1,
   1,
   0,
   1,
   1,
   0,
   1,
   1,
   0,
   1,
   1,
   0,
   1,
   1,
   0,
   1,
   1,
   0,
   1,
   0,
   0,
   0,
   1,
   0,
   1,
   1,
   0,
   1,
   0,
   1,
   2,
   1,
   2,
   1,
   2,
   2,
   1,
   1,
   0,
   1,
 };