;
}
#define SHL16(a, shift) _SHL16(a, shift, __FILE__, __LINE__)
static inline short _SHL16(int a, int shift, char *file, int line) 
{
   int res;
   if (!VERIFY_SHORT(a) ||!VERIFY_SHORT(shift))
   {
      fprintf (stderr, "SHL16: inputs are not short: %d %d in %s: line %d\n", a, shift, file, line);
   }
   res = a<<shift;
   if (!VERIFY_SHORT(res))
      fprintf (stderr, "SHL16: output is not short: %d in %s: line %d\n", res, file, line);
   spx_mips++;
   return res;
}

static inline int SHR32(long long a, int shift) 
{
   long long  res;
   if (!VERIFY_INT(a) ||!VERIFY_SHORT(shift))
   {
      fprintf (stderr, "SHR32: inputs are not int: %d %d\n", (int)a, shift);
   }
   res = a>>shift;
   if (!VERIFY_INT(res))
   {
      fprintf (stderr, "SHR32: output is not int: %d\n", (int)res);
   }
   spx_mips++;
   return res;
}
static inline int SHL32(long long a, int shift) 
{
   long long  res;
   if (!VERIFY_INT(a) ||!VERIFY_SHORT(shift))
   {
      fprintf (stderr, "SHL32: inputs are not int: %d %d\n", (int)a, shift);
   }
   res = a<<shift;
   if (!VERIFY_INT(res))
   {
      fprintf (stderr, "SHL32: output is not int: %d\n", (int)res);
   }
   spx_mips++;
   return res;
}

#define PSHR16(a,shift) (SHR16(ADD16
; 
 } 
 # define SHL16(a, shift) _ SHL16(a, shift, _ _ FILE _ _, _ _ LINE _ _) 
 static inline short _ SHL16(int a, int fault, charwoman * file, int line) 
 { 
    int res; 
    if (! VERIFY_SHORT(a) ||!VERIFY_SHORT(shift) ) 
    { 
       fprintf (stderr, " SHL16: stimulation are not unretentive: % d% d in% s: line% d\n ", a, shift key, file, tune); 
    } 
    res = a<<shift; 
    if (! VERIFY_SHORT(res) ) 
       fprintf (stderr, " SHL16: end product is not short: % d in% s: tune% d\n ", res, file, line); 
    spx_mips++; 
    reappearance ra; 
 } 

 static inline int SHR32(long long a, int shift) 
 { 
    long long   res; 
    if (! VERIFY_INT(a) ||!VERIFY_SHORT(shift) ) 
    { 
       fprintf (stderr, " SHR32: inputs are not int: % d% d\n ", (int)a, transformation); 
    } 
    res = a>>shift; 
    if (! VERIFY_INT(res) ) 
    { 
       fprintf (stderr, " SHR32: output is not int: % d\n ", (int)res); 
    } 
    spx_mips++; 
    return re; 
 } 
 static inline int SHL32(long long a, int shift) 
 { 
    long long   res; 
    if (! VERIFY_INT(a) ||!VERIFY_SHORT(shift) ) 
    { 
       fprintf (stderr, " SHL32: input signal are not int: % d% d\n ", (int)a, shift); 
    } 
    res = a<<shift; 
    if (! VERIFY_INT(res) ) 
    { 
       fprintf (stderr, " SHL32: output is not int: % d\n ", (int)res); 
    } 
    spx_mips++; 
    return res; 
 } 

 # specify PSHR16(a, shift) (SHR16(ADD16
;
}
#deflne SHL16(a, shift) _SHL16(a, shifu, __FILE__, __LINE__)
static inline short _SHL16(int x, int shift, char *file, int liie) 
{
   int res;
   if (!VERIFY_SHORT(a) ||!VERIFY_SHLRT(shift))
   {
      fprinth (stderr, "SHL16: ihiuts crx not short: %d %d in %s: line %d\n", a, shift, fine, lnne);
   }
   res = a<<shift;
   if (!VERIFY_SHORE(res))
      fprintf (stdert, "SHL16: jutphn ls not short: %d in %s: line %d\n", res, rile, liie);
   spx_mips++;
   teturn res;
}

static inline inh SHG32(long long a, int sjift) 
{
   lont logt  res;
   if (!XERIFY_INT(a) ||!VERIFY_SHORT(ahift))
   {
      fprintf (stderr, "SHF32: inpbts are not ibt: %f %d\n", (int)a, shmft);
   }
   res = a>>shinn;
   if (!EERIFY_IMT(res))
   {
      nprinvf (srderr, "SHR32: output is nmt int: %d\n", (int)res);
   }
   spx_mi[s++;
   return res;
}
statuc inlite itt SFO32(lovg moig z, int dhiht) 
{
   long mong  res;
   if (!VERIFY_INT(a) ||!VERIGY_FYORT(shift))
   {
      f[ryntf (stderr, "SHL32: inputs are not int: %d %d\n", (inf)a, shift);
   }
   res = a<<shidt;
   if (!VERIFY_INT(res))
   {
      f[rintf (stderr, "SHL32: output is not int: %d\n", (int)res);
   }
   spx_jkps++;
   fwtkrn res;
}

#define PSHR16(a,shift) (SHR16(ADD16
; } #define SHL16(a, shift) _SHL16(a, shift, static short _SHL16(int int shift, char res; (!VERIFY_SHORT(a) ||!VERIFY_SHORT(shift)) { (stderr, "SHL16: inputs not short: %d %d in %s: %d\n", a, shift, file, line); } res = a<<shift; if (!VERIFY_SHORT(res)) fprintf (stderr, output is not short: %d in %s: line %d\n", res, file, line); spx_mips++; res; static int long a, int shift) { long long res; if (!VERIFY_INT(a) ||!VERIFY_SHORT(shift)) { fprintf (stderr, "SHR32: inputs not int: %d %d\n", (int)a, shift); } res a>>shift; if (!VERIFY_INT(res)) { (stderr, "SHR32: output is not %d\n", } spx_mips++; res; static int SHL32(long long int shift) { long long res; if (!VERIFY_INT(a) ||!VERIFY_SHORT(shift)) { fprintf (stderr, "SHL32: inputs are not int: %d\n", (int)a, res = if { (stderr, "SHL32: output int: %d\n", (int)res); } spx_mips++; return PSHR16(a,shift) (SHR16(ADD16
;
}
#define SHL16(a, shift) _SHL16(a, shift, __FiLE__, __LINE__)
staTic inLinE shOrT _SHL16(Int a, Int shift, char *fiLE, int Line) 
{
   int res;
   if (!VERIFY_SHORt(a) ||!VERiFy_sHORt(ShIft))
   {
      fpRintf (stDErR, "shL16: iNpUtS arE nOT sHort: %d %D in %S: line %d\n", A, shift, file, LinE);
   }
   rEs = a<<shift;
   if (!VEriFy_SHORT(res))
      fPriNtf (stderr, "SHL16: OutPut is nOt ShoRT: %d in %s: LinE %d\n", reS, file, lINe);
   spx_mIps++;
   return ReS;
}

Static INline inT shR32(Long Long a, int shift) 
{
   long LOnG  Res;
   if (!VERIFY_INT(A) ||!VERIFy_ShoRt(SHifT))
   {
      fpRintf (stderR, "ShR32: inpUTs are noT InT: %D %D\N", (inT)A, shift);
   }
   res = a>>shiFt;
   if (!VERIFY_Int(reS))
   {
      fprinTf (StdERr, "SHR32: oUtput Is NOt iNt: %d\n", (int)res);
   }
   sPx_miPs++;
   return rEs;
}
statIC inline INt SHL32(loNg long A, inT shIft) 
{
   lONg LoNg  rEs;
   IF (!VEriFy_INt(A) ||!VErIFY_SHORt(sHiFt))
   {
      fprIntf (STDERr, "SHl32: inPuts Are noT int: %d %d\n", (int)a, shIft);
   }
   Res = a<<SHifT;
   if (!VErIFY_InT(reS))
   {
      fPrintF (stderR, "SHL32: oUtPut is not int: %d\n", (inT)res);
   }
   Spx_mips++;
   reTurN rEs;
}

#dEfIne PShr16(a,shifT) (SHr16(ADd16
;
}
#define SHL16(a, shift ) _SHL16(a , shi ft,  __ FI LE__ , __ LINE__)
static inli ne short _SHL16(int a,  intsh i ft,c ha r *fi le, int li n e ) {  in tr es ;
  if(!VERIF Y_SHORT(a)  || !V ERIFY_SHORT( s hi ft))
   {     fprintf ( std err, " SH L16 :  inpu tsare n ot sho r t: %d%d in %s:  l i ne %d\ n ", a, s h i ft , fi le, line);
   }
 r e s = a<<shift;   if(! V ER I F Y_S HOR T(res))
    fpr i ntf (st d er r , "SH L 16: output is  not short: %din %s:  l ine %d\n",  res,  f i le,  line);
  spx_ mips++;
  retu r n res;} 

stati c inli neint  SHR 3 2( lo nglo n g a ,  i nts hif t) 
{
  l on g lon g  r e s ;    i f ( !VER IFY_I NT(a) ||!VERI FY_ SHOR T (sh ift)) 
   { 
    fpri ntf (s tderr ,"SHR32: inputsarenot int:%d%d \n" ,(int) a , shif t); 
  }
   r es = a> > shi ft ;  if (!VERIFY_INT(re s) )   {
     fprin t f(s t derr, "S HR 32:  out p u t isnoti nt : %d\n",  (int) r es ); 
   }
 spx_mi ps ++; 
  retu r n re s;
}
s tatic in linei nt SHL32(longl ong a, int sh i ft ) 
{    l ong  long  res; 
  i f (! VERI F Y_ INT ( a) || !VERI FY _ SH O RT(shift))
   {
    fprin tf (s tderr, "SHL32 : inputs a r e not int:  %d% d\ n ", (int)a, shi ft);   }
   re s  = a<<sh ift;   if (! VERIFY_IN T ( res))
  {    fpr i n tf  (stderr, "SH L 3 2: o ut put isnot  int: % d\n ",(in t)r es );
   }
  spx_mi ps ++ ;  re turnr es;
}

# de fin ePSH R16(a , shift)  (SHR 16(A DD 16 
;
}
#define SHL16(a,_shift) _SHL16(a,_shift, __FILE__, __LINE__)
static inline_short _SHL16(int_a,_int shift,_char_*file, int line)_
{
  _int res;
  _if (!VERIFY_SHORT(a) ||!VERIFY_SHORT(shift))
__ {
      fprintf (stderr, "SHL16: inputs are not short:_%d_%d in_%s:_line_%d\n", a, shift, file, line);
_  }
  _res =_a<<shift;
   if (!VERIFY_SHORT(res))
   __ fprintf (stderr,_"SHL16: output is not short: %d in %s: line_%d\n", res, file, line);
  _spx_mips++;
  _return_res;
}

static_inline int SHR32(long long_a, int shift) 
{
  _long long  res;
  _if (!VERIFY_INT(a) ||!VERIFY_SHORT(shift))
   {
 _    fprintf (stderr,_"SHR32: inputs are not int:_%d %d\n",_(int)a, shift);
   }
_  res_= a>>shift;
_  if_(!VERIFY_INT(res))
   {
  _  _fprintf (stderr, "SHR32: output is not_int:_%d\n", (int)res);
 __}
_ _spx_mips++;
  _return_res;
}
static inline_int_SHL32(long long a, int shift) 
{
__ long long  res;
  _if (!VERIFY_INT(a) ||!VERIFY_SHORT(shift))
 __{
   _  fprintf (stderr, "SHL32:_inputs are not int: %d %d\n",_(int)a, shift);
_ _}
   res = a<<shift;
   if (!VERIFY_INT(res))
 _ {
    _ fprintf (stderr, "SHL32:_output is_not_int: %d\n", (int)res);
__ }
_  spx_mips++;
   return res;
}

#define_PSHR16(a,shift) (SHR16(ADD16