// nicked from output of PGC Rel 1.4 -opt 2
        .text
        .align  8
        .text



//
// aiming for -
//
// icoeff_p = vpx ( icoeff_ref, codeword, opcode0, conn, backwards, n_polys );
//
// problem - edgizing quads, pents and hexes
//



//{{{  about this code
//
//
// The triangle functions are C-callable, and simply chain together
// calls to other functions in this module, which do not themselves
// adhere to C calling conventions and register allocation
//
// These are the triangle functions - for each type of triangle
// rendereable by the system, a different function exists. The currently
// implemented set of triangles is
//
// _tri_zb_rgb
// _tri_zb_rgb_t
// _tri_zb_d_s
// _tri_zb_d_s_t
// _tri_zb_f
// _tri_zb_f_t
// _tri_zb_d
// _tri_zb_d_t
//
// which are enough to cover PAZ 1 shading model, white light PAZ 2
// shading model, optimized lightscape / Eindhoven radiosity, skyfly
// texturing, white light texturing
//}}}  













































































































































































































































































































































































































































































































































































































































































































































































































































































































//
// integer registers first
//
// icoeff_p = vpx ( icoeff_p, codeword, opcode0, conn, backwards );
// icoeff_p = vpx ( icoeff_p, codeword, opcode0, conn, backwards );
//






//



























//  r12   r13  etc only used early in binitization



//
// fp registers
//

//
// screen-space minimax for binitizing
// PASS NO FLOAT PARAMETERS IN HERE OR YOU ARE    S T U F F E D
//









//
// some sphere-only registers
//














// re-use lz - not needed after load





// x, y coords for tris/quads









// repeated expressions    fx32, fx13, fx21, fC










// screen-space function values for planarizing























//{{{  some load macros





//}}}  
//{{{  declare offsets in VERTEX structure

//
// Note new placement of next field - ensures double-alignment of
// position, normal and texcoords
//
//        typedef struct s_rvert {
//  0       dpl_POINT position;
// 16       dpl_POINT normcol;
// 32       float32 texcoords [3];
// 44       struct s_rvert *next;
// 48       dpl_POINT xform_posn;
// 64       float32 rendered_color[3];
//          int32 touched;
// 80     } dpl_REMOTE_VERTEX;



















//  typedef struct s_conn {
//    struct s_conn *next;             /* 0 */ 
//    int32    r8  ;                  /* 4 */ 
//    dpl_REMOTE_VERTEX*  indices[6];  /* 8 */ 
//    dpl_POINT planeEqn;              /* 32 */ 
//    float32 rendered_color[3];       /* 48 */ 
//    int32 touched;                   /* 60 */ 
//  } dpl_REMOTE_CONNECTION;
//








//}}}  

// /////////////////////////////////
// triangle support code
// preplane, planarize, binitize

//{{{  triangle_entry


//}}}  
//{{{  triangle_exit


//}}}  
//{{{  edgize_fn
//
//  NOTE WEIRDNESSS - in viewing matrix, y was INVERTED - thus,
//  the sign of all Ys in here is flipped. dont think about it, just
//  BELIEVE the expressions below and all will be well...
//
//
//  eqn[0]=p1[Y] - p2[Y];
//  eqn[1]=p2[X] - p1[X];
//  eqn[2]=(p2[Y]*p1[X]) - (p2[X]*p1[Y]);
//
//  NB we already have
//   f21     f22     f20    in registers
//
          .align 8

edgize_fn::

        d.pfsub.ss  f13 ,  f15 , f0
          btne 0x3,   r8  , edgize_poly_fn
        d.pfsub.ss  f15 ,  f17 , f0
          nop
        d.pfsub.ss  f17 ,  f13 , f0
          nop
        d.m12tpm.ss  f12 ,  f15 ,  f28 
          fst.l  f28 ,  8( r22 )  // edge[0] eqn[0]
        d.m12tpm.ss  f14 ,  f17 ,  f29 
          fst.l  f29 , 24( r22 )  // edge[1] eqn [0]
        d.m12tpm.ss  f16 ,  f13 ,  f28 
          fst.l  f28 , 40( r22 )  // edge[2] eqn [0]
        d.pfmul.ss   f13 ,  f14 ,  f31    //  f15 * f12 
          fst.l  f22 , 12( r22 )   // edge[0] eqn [1]
        d.pfmul.ss   f15 ,  f16 ,  f27    //  f17 * f14 
          fst.l  f20 , 28( r22 )  // edge[1] eqn[1]
        d.pfmul.ss   f17 ,  f12 ,  f4    //  f13 * f16 
          fst.l  f21 , 44( r22 )  // edge[2] eqn[1]
        d.i2s1.ss    f31 , f0, f0     // push y2*x1 - x2*y1
          st.l  r11 , 4( r22 )
        d.i2s1.ss    f27 , f0, f0
          st.l  r11 , 20( r22 )
        d.i2s1.ss    f4 , f0, f0
          st.l  r11 , 36( r22 )
        d.pfadd.ss f0, f0,  f28 
          fst.l  f28 , 16( r22 )        // edge[0] eqn[2]
        d.pfadd.ss f0, f0,  f29 
          fst.l  f29 , 32( r22 )        // edge[1] eqn[2]
        pfadd.ss   f0, f0,  f30 
          bri r1
        fnop
          fst.l  f30 , 48( r22 )++      // edge[2] eqn[2]


        // edgize a polygon rather than a triangle...

//}}}  
//{{{  edgize_poly_fn
//  NOTE WEIRDNESSS - in viewing matrix, y was INVERTED - thus,
//  the sign of all Ys in here is flipped. dont think about it, just
//  BELIEVE the expressions below and all will be well...
//
//  eqn[0]=p1[Y] - p2[Y];
//  eqn[1]=p2[X] - p1[X];
//  eqn[2]=(p2[Y]*p1[X]) - (p2[X]*p1[Y]);
//
//  NB we already have
//   f21     f22     f20    in registers
//
          .align 8

edgize_poly_fn_entry::

        d.pfsub.ss  f13 ,  f15 , f0
          nop
edgize_poly_fn::

// do 1st 2 edges in optimal manner, then wimp out for remainder

        d.pfsub.ss    f15 ,  f17 , f0
          st.l  r11 , 4( r22 )  // opcode edge 1
        d.m12ttpa.ss  f12 ,  f15 , f0
          fst.l  f22 , 12( r22 )     // edge 1 B
        d.m12ttpa.ss  f14 ,  f13 ,  f28 
          fst.l   f28 , 8( r22 )    // edge 1 A
        d.m12ttpa.ss  f14 ,  f17 ,  f29 
          fst.l   f29 , 24( r22 )   // edge 2 A
        d.m12ttpa.ss  f16 ,  f15 , f0       // x1y2 into t
          st.l  r11 , 20( r22 )
        d.i2st.ss    f0, f0, f0         // x1y2 - x2y1 adder 1
          adds -2,   r8  ,   r8  
        d.i2ap1.ss   f0, f0, f0         // x2y3 into t       2
          fst.l  f20 , 28( r22 )++     // edge[1] eqn[1]
        d.i2st.ss    f0, f0, f0         // x2y3-x3y2->a.1, x1y2-x2y1->a.3
          xor 0x1,   r8  , r0
        d.pfadd.ss   f0, f0,  f28       // edge 1 C
          fst.l   f28 , -12( r22 )
        d.pfadd.ss   f0, f0, f0
          bte 0x1,   r8  , edgize_last_poly_vert

//
// ok - what about rest of edges ?
//
// we have executed edges 1->2 and 2->3
// for all remaining edges BUT THE LAST,
//   copy 2->3, load new 3, re-execute 2->3
//
// use x3 y3 and x2 y2 to construct edge
//  eqn[0]=y2-y3
//  eqn[1]=x3-x2
//  eqn[2]=y3*x2 - x3*y2
//
//  r29 =vertex_index
//  r30 =vertex_ptr
//
// set  r29 =2, ready for increment
// and re-execute last instruction due to bc.t !
//
        d.fnop
          or ( 8 +12), r0,  r29 
//  move x3y3 to x2y2, and load x3y3
carry_on_branching::
        d.fmov.dd  f16 ,  f14 
          ld.l  r29 ( r24 ),  r30 
        d.pfadd.ss   f0, f0,  f28       // edge 2 C
          fld.d  48 ( r30 ),  f16 
        d.pfsub.ss    f15 ,  f17 , f0
          fst.l   f28 , 4( r22 )++
        d.pfsub.ss    f16 ,  f14 , f0
          st.l  r11 , 4( r22 )  // opcode edge
        d.m12ttpa.ss  f17 ,  f14 , f0
          nop
        d.m12ttpa.ss  f15 ,  f16 ,  f28     // edge A
          fst.l   f28 , 8( r22 )++
        d.m12ttpa.ss f0, f0,  f29 
          fst.l   f29 , 4( r22 )++  // edge B
        d.m12ttpa.ss f0, f0, f0         // y1x3->t
          adds 4,  r29 ,  r29 
        d.i2st.ss    f0, f0, f0         // y3x1 - x3y1  into adder 1
          adds -1,   r8  ,   r8  
        d.pfadd.ss   f0, f0, f0         // y3x1 - x3y1  into adder 2
          ld.l  r29 ( r24 ),  r30 
        d.pfadd.ss   f0, f0, f0           // y3x1 - x3y1  into adder 3
          btne 0x1,   r8  , carry_on_branching

edgize_last_poly_vert::
// use x3 y3 and x1 y1 to construct edge
//  eqn[0]=y3-y1
//  eqn[1]=x1-x3
//  eqn[2]=y1*x3 - x1*y3
//  only x1y1 are known good, so re-load x2y2 and x3y3

        d.pfadd.ss   f0, f0,  f28         // y3x1 - x3y1  into  f28 
          fst.l   f28 , 4( r22 )++  // edge C and exit
        d.pfsub.ss    f17 ,  f13 , f0
          st.l  r11 , 4( r22 )  // opcode edge
        d.pfsub.ss    f12 ,  f16 , f0
          nop
        d.m12ttpa.ss  f13 ,  f16 , f0
          nop
        d.m12ttpa.ss  f17 ,  f12 ,  f28     // edge A
          fst.l   f28 , 8( r22 )++
        d.m12ttpa.ss f0, f0,  f29 
          fst.l   f29 , 4( r22 )++  // edge B
        d.m12ttpa.ss f0, f0, f0         // y1x3->t
          nop
        d.i2st.ss    f0, f0, f0         // y3x1 - x3y1  into adder 1
          fld.d  48 (  r19  ),  f14 
        d.pfadd.ss   f0, f0, f0         // y3x1 - x3y1  into adder 2
          fld.d  48 ( r20 ),  f16 
        pfadd.ss   f0, f0, f0           // y3x1 - x3y1  into adder 3
          bri r1
        pfadd.ss   f0, f0,  f28         // y3x1 - x3y1  into  f28 
          fst.l   f28 , 4( r22 )++  // edge C and exit

//}}}  
//{{{  preplanarize_fn_p
//
//
//

        .globl _preplanarize_fn_p
        .align 8

//
// preplanarize_fn  ( float *coeffs, unused, v1, v2, v3, v4 );
//
// preplanarize sets up all of the triangle code
//
// we need to cache all x,y into registers,
// precompute x23, x31, x12 and C, and determine
// minimax x, y for the triangle
//
// VICIOUS - returns TRIV_REJECT in r31
//
//
_preplanarize_fn_p::




       adds  8 , r0,  r30    // index into vert[2] of connection
        orh ha% .C00037 , r0, r31; fld.l l% .C00037 (r31),   f30   
       ld.l  r30 ( r24 ),   r9           //   r9   is vertex[0]
        orh ha% .C362436 , r0, r31; fld.l l% .C362436 (r31),   f28   
       fld.d  48 (  r9  ),  f8 
       fld.l  (( 48 ) + 8) (  r9  ),  f5 
        orh ha% .Cmax_x , r0, r31; fld.d l% .Cmax_x (r31),    f18    

       fmov.dd  f8 ,  f10 
       fmov.ss  f5 ,  f2 

       // rvert_p should be pointing at conn->verts[0]
       // nv should be a temp, ditto minus1

       adds -2,    r8  , r31 // set up for bla - will loop twice on triangle
       adds -1,  r0,  r29     // auto-dec for bla
       adds  4,   r30 ,  r30  // bump vertex for minimax tests

       bla  r29 , r31, vertloop_db
  vertloop::
       ld.l  r30 ( r24 ),   r9  
  vertloop_db::
       fld.d  48 (  r9  ),  f14 

       pfgt.ss  f14 ,  f10 , f0
       bnc  xmax_ok
       br xmin_ok
       fmov.ss  f14 ,  f10 
   xmax_ok::
       pfgt.ss  f8 ,  f14 , f0
       bnc  xmin_ok
       fmov.ss  f14 ,  f8 

   xmin_ok::
   ycheck::
       pfgt.ss  f15 ,  f11 , f0
       bnc  ymax_ok
       br ymin_ok
       fmov.ss  f15 ,  f11 
   ymax_ok::
       pfgt.ss  f9 ,  f15 , f0
       bnc  ymin_ok
       fmov.ss  f15 ,  f9 
   ymin_ok::

   zcheck::
       bte 0x0,  r21 , zmin_ok
       fld.l  (( 48 ) + 8) (  r9  ),  f25 

       pfgt.ss  f25 ,  f2 , f0
       bnc  texscale_ok
       br zmin_ok
       fmov.ss  f25 ,  f2 
   texscale_ok::
       pfgt.ss  f5 ,  f25 , f0
       bnc  zmin_ok
       fmov.ss  f25 ,  f5 
   zmin_ok::
       bla  r29 , r31, vertloop
       adds 4,  r30 ,  r30 

 // re-load x any y registers we have trashed

       fld.d  48 (  r18  ),  f12 
       fld.d  48 (  r19  ),  f14 
       fld.d  48 ( r20 ),  f16 

// now pipe up repeated expressions
        pfsub.ss  f13 ,  f15 , f0
        pfsub.ss  f17 ,  f13 , f0
        pfsub.ss  f15 ,  f17 , f0
        pfsub.ss f0,  f0,    f22  
        pfsub.ss f0,  f0,    f21  
        pfsub.ss f0,  f0,    f20  

// repeated expressions     f20 ,  f21 ,  f22 ,  f23 
//
// The definitive planarization algorithm
//
//  invC=1.0f / ( f12  * ( f15  -  f17 )) +
//              ( f14  * ( f17  -  f13 )) +
//              ( f16  * ( f13  -  f15 ));
//
//  eqn[0]= invC*( f13  * ( f26  -  f25 )) +
//               ( f15  * ( f24  -  f26 )) +
//               ( f17  * ( f25  -  f24 ));
//
//  eqn[1]= invC*( f24  * ( f16  -  f14 )) +
//               ( f25  * ( f12  -  f16 )) +
//               ( f26  * ( f14  -  f12 ));
//
//  eqn[2]= invC*( f12 *(( f15 * f26 ) - ( f17 * f25 ))) +
//               ( f14 *(( f17 * f24 ) - ( f13 * f26 ))) +
//               ( f16 *(( f13 * f25 ) - ( f15 * f24 )));
//


        // 11 ticks all told

        pfmul.ss   f12 ,   f20  , f0
        pfmul.ss   f14 ,   f21  , f0
        pfmul.ss   f16 ,   f22  , f0
        // use T-reg as staging post...
        rat1s2.ss  f12 ,  f16 ,  f0
        i2pt.ss f0, f0, f0
        rat1s2.ss  f14 ,  f12 , f0
        pfsub.ss   f16 ,  f14 ,  f21 
        i2apt.ss  f0, f0, f0
        pfadd.ss  f0, f0,  f22 
        pfadd.ss  f0, f0,  f20 
        pfadd.ss  f0, f0,  f23 

// ******************************************
// clamp minimax against screen max coordinates
// now get real minimax xy for binning
//
//  firstly check triv rejection, max < 0 etc.
//

        pfgt.ss  f28 ,  f10 , f0
        bc .triv_reject

        pfgt.ss  f28 ,  f11 , f0
        bc .triv_reject

        pfgt.ss  f8 ,   f18  , f0
        bc .triv_reject

        pfgt.ss  f9 ,   f19  , f0
        bc .triv_reject

// now check binning
// get real minx
        pfgt.ss  f8 , f0, f0
        bc  .no_clamp_fminx
        fmov.ss f0,  f8 

.no_clamp_fminx::

// get real miny
        pfgt.ss  f9 , f0, f0
        bc  .no_clamp_fminy
        fmov.ss f0,  f9 

.no_clamp_fminy::

// get real maxx
        pfgt.ss   f18  ,  f10 , f0
        bc  .no_clamp_fmaxx
        fmov.ss   f18  ,  f10 

.no_clamp_fmaxx::
// get real maxy
        pfgt.ss   f19  ,  f11 , f0
        bc  .no_clamp_fmaxy
        fmov.ss   f19  ,  f11 

.no_clamp_fmaxy::

// if entire patch is on-screen, we can just come here

// ok, lets think about the minimum area test
// we have in registers x13 x21 x32
// and                  y31 y12 y23
//
//
// we need to check that (x21*y21) + (x32*y32) + (x13*y13) < min
// SO we compute          (x21*y12  + x32*y23 + x13*y31) > min
//
//  around 18 tick overhead, reduce to 12 ish by pfs
//
//        fmul.ss  f22 ,   f22  ,  f28       // 3
//        fmul.ss  f20 ,   f20  ,  f29       // 6
//        fmul.ss  f21 ,   f21  ,  f30       // 9
//        fadd.ss  f28 ,  f29 ,  f29     // 12
//        fadd.ss  f30 ,  f29 ,  f29     // 15
//        pfgt.ss  f29 ,  f28 , f0       // 17

        pfmul.ss  f22 ,   f22  , f0   // 1
        pfmul.ss  f20 ,   f20  , f0   // 2
        pfmul.ss  f21 ,   f21  , f0   // 3
        i2ap1.ss f0, f0, f0       // 4  last-stage mul into T
        i2pt.ss  f0, f0, f0       // 5  add last-stage mul and T
        i2ap1.ss f0, f0, f0       // 6  last-stage mul into T again
        pfadd.ss f0, f0, f0       // 7  adder stage3 now x21*y12
        i2apt.ss f0, f0, f0       // 8  add adder 3 and T
        pfadd.ss f0, f0, f0       // 9  adder stage2 now result
        pfadd.ss f0, f0, f0       // 10 adder stage3 now result
        pfadd.ss f0, f0,  f29     // 11
        pfgt.ss  f29 ,  f28 , f0  // 12

        bnc .triv_reject

        //
        // straight out of the i860 prog ref man
        //
        // to iterate towards 1/V;
        //
        // G_new=G_old*(2.0f-(G_old*V))
        //
        // 20 ticks !? pretty poor
        frcp.ss    f23 ,  f28             // start 1.0 /  f23  - 2^-8
        fmul.ss    f23 ,  f28 ,  f29      // guess * divisor
        // fld.l 16(r31),  f2 
        fsub.ss    f30 ,  f29 ,  f29   // 2 - (guess * divisor)
        fld.l  r17 (  r18  ),  f24 
        fmul.ss    f28 ,  f29 ,  f28   // 2^-15
        fld.l  r17 (  r19  ),  f25 
        fmul.ss    f23 ,  f28 ,  f29      // guess * divisor
        fsub.ss    f30 ,  f29 ,  f29   // 2 - (guess * divisor)
        fld.l  r17 ( r20 ),  f26 
        fmul.ss    f28 ,  f29 ,  f23      // 2^-23 - run with it
        bri r1
        or 0x0, r0, r31

.triv_reject::
        bri r1
        or 0x1, r0, r31

//}}}  
//{{{  _planarize_fn_p     pipelined
//
// Hey Ho Lets Go!
//
// The definitive planarization algorithm
//
//  invC=1.0f / ( f12  * ( f15  -  f17 )) +
//              ( f14  * ( f17  -  f13 )) +
//              ( f16  * ( f13  -  f15 ));
//
//  eqn[0]= invC*( f13  * ( f26  -  f25 )) +
//               ( f15  * ( f24  -  f26 )) +
//               ( f17  * ( f25  -  f24 ));
//
// a =  f26  -  f25 
// b =  f24  -  f26 
// c =  f25  -  f24 
// d =  f13  * a
// e =  f15  * b
// f =  f17  * c
// g = d + e
// h = g + f
// eqn[0] =  f23  * h
//
//  eqn[1]= invC*( f24  * ( f16  -  f14 )) +
//               ( f25  * ( f12  -  f16 )) +
//               ( f26  * ( f14  -  f12 ));
//
// i =  f24  *  f20 
// j =  f25  *  f21 
// k =  f26  *  f22 
// l = i + j
// m = k + l
// eqn[1] =  f23  * m
//
//  eqn[2]= invC*( f12 *(( f15 * f26 ) - ( f17 * f25 ))) +
//               ( f14 *(( f17 * f24 ) - ( f13 * f26 ))) +
//               ( f16 *(( f13 * f25 ) - ( f15 * f24 )));
//
// n =  f15  *  f26 
// o =  f17  *  f25 
// p =  f17  *  f24 
// q =  f13  *  f26 
// r =  f13  *  f25 
// s =  f15  *  f24 
// t = n - o
// u = p - q
// v = r - s
// w =  f12  * t
// x =  f14  * u
// y =  f16  * v
// z = w + x
// aa= y + z
// eqn[2] = invC * aa
//





        .globl _planarize_fn_p
        .align 8

_planarize_fn_p::
        //                           m1 m2 m3 | T | a1 a2 a3 | KR | t1 t2 t3
        pfmul.ss  f15 ,  f26 , f0     //  n  ?  ? | ? | ?  ?  ?  | ?  | ?  ?  ?
        pfmul.ss  f17 ,  f25 , f0     //  o  n  ? | ? | ?  ?  ?  | ?  | ?  ?  ?
        pfmul.ss  f17 ,  f24 , f0     //  p  o  n | ? | ?  ?  ?  | ?  | ?  ?  ?

        mm12ttpm.ss  f13 ,  f26 , f0  //  q  p  o | n | ?  ?  ?  | ?  | ?  ?  ?
        m12tsm.ss  f13 ,  f25 , f0    //  r  q  p | ? | t  ?  ?  | ?  | ?  ?  ?
        mm12ttpm.ss  f15 ,  f24 , f0  //  s  r  q | p | ?  t  ?  | ?  | ?  ?  ?
        m12tsm.ss  f24 ,  f20 ,  f0  //  i  s  r | ? | u  ?  t  | ?  | ?  ?  ?
        pfsub.ss   f26 ,  f25 ,   f28     //  i  s  r | ? | a  u  ?  | ?  | t  ?  ?
        mm12ttpm.ss  f25 ,  f21 , f0 //  j  i  s | r | ?  a  u  | ?  | t  ?  ?
        m12tsm.ss  f26 ,  f22 ,   f29    //  k  j  i | ? | v  ?  a  | ?  | t  u  ?
        pfmul.ss   f12 ,   f28  ,   f30     //  w  k  j | ? | v  ?  a  | ?  | ?  u  i
        pfmul.ss   f14 ,   f29  ,   f28     //  x  w  k | ? | v  ?  a  | ?  | j  ?  i
        pfadd.ss    f28  ,   f30  ,    f29    //  x  w  k | ? | l  v  ?  | ?  | ?  a  ?
        mm12mpm.ss  f13 ,   f29  ,   f30    //  d  x  w | ? | ?  l  v  | ?  | ?  ?  k
        d.pfsub.ss   f24 ,  f26 ,   f28     //  d  x  w | ? | b  ?  l  | ?  | v  ?  k
          nop
        d.pfsub.ss   f25 ,  f24 ,   f29     //  d  x  w | ? | c  b  ?  | ?  | v  l  k
          fld.l  r17 ( r20 ),  f26 
        d.rat1p2.ss    f29  ,   f30  , f0   //  ?  d  x | w | m  c  b  | ?  | v  ?  ?
          nop
        d.m12tpm.ss   f16 ,   f28  ,   f29    //  y  ?  d | ? | z  m  c  | ?  | ?  b  ?
          nop
        d.m12ttpa.ss  f15 ,   f29  ,   f28    //  e  y  ? | d | ?  z  m  | ?  | c  ?  ?
          fld.l   r17 (  r19  ),  f25 
        d.m12apm.ss   f17 ,   f28  ,   f29    //  f  e  y | d | ?  ?  z  | ?  | ?  m  ?
          nop
        d.pfmul.ss     f23 ,    f29  ,   f28   //  e1 f  e | d | ?  ?  z  | ?  | y  ?  ?
          nop
        d.r2pt.ss      f23 ,  f0,    f29   //  ?  e1 f | ? | g  ?  ?  | ?  | y  z  ?
          fld.l  r17 (  r18  ),  f24 
        d.mrm1p2.ss     f28  ,   f29  ,   f30   //  ?  ?  e1| ? | aa g  ?  | ?  | ?  ?  f
          nop
        d.mm12mpm.ss  f0, f0,   f29     //  ?  ?  ? | ? | ?  aa g  | ?  | ?  e1 f
          st.l   r16 , 4( r22 )
        d.r2ap1.ss      f30  , f0, f0   //  ?  ?  ? | ? | h  ?  aa | ?  | ?  e1 ?
          nop
        d.ra1p2.ss    f0, f0, f0    //  e2 ?  ? | ? | ?  h   ? | ?  | ?  e1 ?
          nop
        d.i2p1.ss     f0, f0, f0    //  ?  e2 ? | ? | ?  ?  h  | ?  | ?  e1 ?
          fst.l        f29  , 12( r22 )
        d.rat1p2.ss   f0, f0, f0
          nop
        d.mi2p1.ss  f0, f0,   f28  
          nop
        d.mi2p1.ss     f30  , f0, f0
          fst.l        f28  , 16( r22 )++
        mi2p1.ss    f0, f0,   f30  
          bri r1
        fnop
          fst.l        f30  , -8( r22 )




//}}}  
//{{{  _texture_rescale
        .globl _texture_rescale
        .align 8

_texture_rescale::




        //
        // ENSURE YOU CALL THIS STRAIGHT AFTER PLANARIZING texu, v and z !!!
        //
        // note that at the nearest point on a triangle, the texz value is
        // forced to 'turn_tex_to_z'. premultiply the far z by 8. then
        //
        // while (far_z < turn_tex_to_z) {
        //   enable_pixels_if_lt_turn_tex_to_z_by_8;
        //   far_z *= 8.0f;
        // }
        //
        // i.e repeatedly execute MEMltTREE_C1 ( turn_z_to_tex / 8);
        //
        //  r22  points at the next free word
        //
        //      i just wrote
        //                   tree a b c
        //                   tree a b c
        //                   tree a b c
        // ==>               tree_lt_mem c
        //                   tree 8a  8b  8c
        //                   tree 8a  8b  8c
        //                   tree 8a  8b  8c
        //
        // so the first tree is at  r22 -(12*4)

         orh ha% _.Cturn_z_to_tex_by_4 , r0, r31; fld.l l% _.Cturn_z_to_tex_by_4 (r31),    f29    

         orh ha% .four_point_0 , r0, r31; fld.l l% .four_point_0 (r31),    f30    

        // precompute this opcode in parallel with multiply
          or (   ( 0x300 | ((( ( 154 ) ) & 0xff) << 0) )  )&0xffff, r0,  r17  ;  orh ((   ( 0x300 | ((( ( 154 ) ) & 0xff) << 0) )  )>>16)&0xffff,  r17 ,  r17   

        // adds 1, r0,  r28       // this 1 deals with push / pop opcodes
        fmul.ss   f30  ,  f5 ,  f5   // minz*=8

        adds 4,  r22 ,  r22 
        // so now  r22  is next free opcode

        // precompute the selective disable opcode
        // N.B - STAY ENABLED if my texz < (tex_to_z / 8)
          or (  ( ( 0x422100 | ((( ( ( 32 ) ) ) & 0xff) << 0) | ((((( ( ( 20 ) ) )+2)+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x422100 | ((( ( ( 32 ) ) ) & 0xff) << 0) | ((((( ( ( 20 ) ) )+2)+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )>>16)&0xffff,  r16 ,  r16   

        // the delayed branch op
        fld.l   -(12*4)( r22 ),  f4 

.loop_8x:
        pfgt.ss  f5 ,  f2 , f0
        bc .done_8x

        // do texu - note delayed branch opcode is missing
        fld.l   -(11*4)( r22 ),  f6 
        fld.l   -(10*4)( r22 ),  f7 
        fld.l   -(9*4)( r22 ),    f31  

        pfmul.ss   f30  ,  f6 , f0
        pfmul.ss   f30  ,  f7 , f0
        pfmul.ss   f30  ,   f31  , f0
        pfmul.ss f0, f0,  f6 
        pfmul.ss f0, f0,  f7 
        pfmul.ss f0, f0,   f31  

        // do the disable pixels thing
        st.l   r16 , 0( r22 )
        fst.l   f29  , 4( r22 )

        fst.l    f4 , 8( r22 )
        fst.l    f6 , 12( r22 )
        fst.l    f7 , 16( r22 )
        fst.l     f31  , 20( r22 )

        // do texu
        fld.l   -(8*4)( r22 ),  f4 
        fld.l   -(7*4)( r22 ),  f6 
        fld.l   -(6*4)( r22 ),   f7 
        fld.l   -(5*4)( r22 ),    f31  

        pfmul.ss   f30  ,  f6 , f0
        pfmul.ss   f30  ,  f7 , f0
        pfmul.ss   f30  ,   f31  , f0
        pfmul.ss f0, f0,  f6 
        pfmul.ss f0, f0,  f7 
        pfmul.ss f0, f0,   f31  

        fst.l    f4 , 24( r22 )
        fst.l    f6 , 28( r22 )
        fst.l    f7 , 32( r22 )
        fst.l     f31  , 36( r22 )

        // do texv
        fld.l   -(4*4)( r22 ),  f4 
        fld.l   -(3*4)( r22 ),  f6 
        fld.l   -(2*4)( r22 ),  f7 
        fld.l   -(1*4)( r22 ),   f31  

        pfmul.ss   f30  ,  f6 , f0
        pfmul.ss   f30  ,  f7 , f0
        pfmul.ss   f30  ,   f31  , f0
        pfmul.ss f0, f0,  f6 
        pfmul.ss f0, f0,  f7 
        pfmul.ss f0, f0,   f31  

        fst.l    f4 , 40( r22 )
        fst.l    f6 , 44( r22 )
        fst.l    f7 , 48( r22 )
        fst.l     f31  , 52( r22 )

        fmul.ss   f30  ,  f5 ,  f5 

        adds 7,   r28 ,  r28 
        adds 56,  r22 ,  r22 
        bte  22,  r28 , .done_8x

        // clamp at a maximum of 3 rescans, roughly 1.5x time

        br .loop_8x  // do something in delayed branch!!
        fld.l   -(12*4)( r22 ),  f4 

.done_8x:
        bri r1
        st.l  r17 , 0( r22 )



//}}}  
//{{{  locals defines for this fn




// head, tail

// DMA_opcodes[512]
// int  r8 
// *next

// byte count of 254*2








// 16 bins in 1024
//}}}  
//{{{  the incredibly expensive 'bin is full branch'
// dont panic -
// this branch is infrequent - happens every 256 triangles
// note that it can result in a call to malloc!
//
// if ( r9 -> r8  ==  2032 ) {
//   binchunk *nextbin=next_binchunk ();
//
//    r9 ->DMA_opcodes[ r8 ++]=(int) nextbin;
//    r9 ->DMA_opcodes[ r8 ++]= ( 0x00000000 ) ;
//    r9 =nextbin;
//    r5 ->tail= r9 ;
//    r8 =0;
// }

//
// damn, we enter C land here - push all registers onto stack
// note that floating-point registers are no longer needed
//

        .align 8

bin_was_full::
        st.l r16,  -4(sp)
        st.l r17,  -8(sp)
        st.l r18, -12(sp)
        st.l r19, -16(sp)
        st.l r20, -20(sp)
        st.l r21, -24(sp)
        st.l r22, -28(sp)
        st.l r23, -32(sp)
        st.l r24, -36(sp)
        st.l r25, -40(sp)
        st.l r26, -44(sp)
        st.l r27, -48(sp)
        st.l r28, -52(sp)
        st.l r29, -56(sp)
        st.l r30, -60(sp)
        st.l r1,  -64(sp)

        call _next_binchunk
        adds -80, sp, sp

        // lets restore registers
        adds  80, sp, sp
        ld.l  -8(sp), r17
        ld.l -12(sp), r18
        ld.l -16(sp), r19
        ld.l -20(sp), r20
        ld.l -24(sp), r21
        ld.l -28(sp), r22
        ld.l -32(sp), r23
        ld.l -36(sp), r24
        ld.l -40(sp), r25
        ld.l -44(sp), r26
        ld.l -48(sp), r27
        ld.l -52(sp), r28
        ld.l -56(sp), r29
        ld.l -60(sp), r30
        ld.l -64(sp), r1

        // now  r16  holds nextbin

        adds  r8 ,  r9 , r31            // construct pointer to coeff store
        st.l  r16 ,  2044 ( r9 ) // do linked list thing
        mov  r16 ,  r9                 // return val from next_binchunk
        st.l  r16 , 0(r31)            // save it away
        adds  ( 0x00000000 ) , r0,  r16       // chain in new  r9 
        st.l  r16 , 4(r31)            // and save this opcode away

        // restore  r16 
        ld.l  -4(sp), r16


        // so now to patch up the new  r9  - simply fall thru
        // into the  r9  not full branch
        mov  r0,  r8 
        bri  r1
        st.l  r9 ,  4 ( r5 )
//}}}  
//{{{  safe_binitize_fn   pipelined intro
// void safe_binitize ( int    macro_lo, int    macro_hi,
//                      float   f8 ,    float   f9 ,
//                      float   f10 ,    float   f11 ,
//                      int    screen_bins_x )
//
// binitize a triangle known to be on-screen, i.e minimax x y
// are within screen-space
//
        .globl _safe_binitize_fn
        .align 8

// binitize a primitive
        .align 8

_safe_binitize_fn::
        //
        // NB fxfr MUST have NOP as companion, or you are shafted
        //
        //  minx=(int)  f8 ;
        //  miny=(int)  f9 ;
        //  maxx=(int)  f10 ;
        //  maxy=(int)  f11 ;
        //  minx >>=  6 ;
        //  miny >>=  7 ;
        //  maxx >>=  6 ;
        //  maxy >>=  7 ;
        //  {
        //    screenbin * r4 =&screenbins[(miny<<bins_shift)+minx];
        //    screenbin * r5 = r4 ;
        //    ==>  go mango

        //  r22  holds last place we wrote
        //  r23  is base of data
        // so, ( r22 +7 - rcoeffbase) >> 3 gives n_words

        ixfr    r23 ,   f24    //  f24 
        adds   7,  r22 , r31
        subs   r31,  r23 ,  r23 
        shr    0x3,  r23 , r31
        orh ( 0x10000000 >>16)&0xffff, r31,  r17 
        adds   35,  r22 ,  r22 

        d.pftrunc.sd  f8 , f0
          andnot 31,  r22 ,  r23 
        d.pftrunc.sd  f9 , f0
          orh ha%_screenbins, r0, r31
        d.pftrunc.sd  f10 , f0
          ld.l l%_screenbins(r31), r31
        d.pftrunc.sd  f11 ,  f28 
          ixfr  r17 , f25  //  f25 
        d.fxfr  f28 ,  r29 
          nop
        d.pfadd.sd f0, f0,  f30 
          shr  6 ,  r29 ,  r12 
        d.fxfr  f30 ,  r30 
          nop
        d.pfadd.sd f0, f0,  f28 
          shr  7 ,  r30 ,  r13 
        d.fxfr  f28 ,  r29 
          nop
        pfadd.sd f0, f0,  f30 
          shr  6 ,  r29 ,  r14 
        fxfr  f30 ,  r30 
          nop

        shl  4 ,  r13 ,  r4 
        adds  r12 ,  r4 ,  r4 
        shr  7 ,  r30 ,  r15 

        // each  r9  is head/tail pointer, so 8 bytes per  r9  entry
        shl  3,      r4 ,   r4 
        adds r31,    r4 ,   r4 
        subs  r15 ,  r13 ,  r6 





// while ( r6 )
_y_loop::
        mov  r4 ,  r5 
_y_loopdb::
        subs  r14 ,  r12 ,  r7 

// while ( r7 )
_x_loop::
        ld.l  4 ( r5 ),  r9 
_x_loopdb::
        ld.l  2040 ( r9 ),  r8 
        xor  2032 ,  r8 , r0
        bnc.t _bin_not_full
        fst.d f24,  r8 ( r9 )

_bin_full::

        st.l r1, -4(sp)

        call bin_was_full
        adds -8, sp, sp

        adds 8, sp, sp
        ld.l -4(sp), r1
        fst.d f24,  r8 ( r9 )

_bin_not_full::
        //         r9 ->DMA_opcodes[ r8 ++]=macro_lo;
        //         r9 ->DMA_opcodes[ r8 ++]=macro_hi;
        //         r9 -> r8 = r8 ;
        //          r5 ++;

        adds  8,  r8 ,  r8 
        adds   8 ,  r5 ,  r5 
        st.l  r8 ,  2040 ( r9 )

_bump_x::
        //  r4 +=screen_bins_x;
        bte  r0,  r7 , _bump_y

        ld.l  4 ( r5 ),  r9 
        br _x_loopdb
        adds -1,  r7 ,  r7 
_bump_y::
        bte  r0,  r6 , _exit_binitize

        adds  128 ,  r4 ,  r4 
        adds -1,  r6 ,  r6 

        br _y_loopdb
        mov  r4 ,  r5 

_exit_binitize:

        bri r1
        nop

//}}}  

//{{{  chunk_fn
             .align 8
chunk_fn::
        subs  r26 ,  r23 , r0
        bnc  .dont_grab_chunk

        // do we need to malloc, or shall we just chain the list
        // find last_coeffchunk from  r26 
        // well -  r26 =lastcoeffchunk+65532-512, so
        // add 512 to  r26 , and we have the next pointer

        // hmm trace regs here ?


        ld.l 512( r26 ),  r23 
        //  r23 =lcc->next
        btne 0x0,  r23 , .dont_malloc

        st.l r16,  -4(sp)
        st.l r17,  -8(sp)
        st.l r18, -12(sp)
        st.l r19, -16(sp)
        st.l r20, -20(sp)
        st.l r21, -24(sp)
        st.l r22, -28(sp)
        st.l r23, -32(sp)
        st.l r24, -36(sp)
        st.l r25, -40(sp)
        st.l r26, -44(sp)
        st.l r27, -48(sp)
        st.l r28, -52(sp)
        st.l r29, -56(sp)
        st.l r30, -60(sp)
        st.l r1,  -64(sp)

        mov 65536, r16

        call _newBytes
        adds -80, sp, sp

        // lets restore registers
        adds  80, sp, sp
        ld.l  -8(sp), r17
        ld.l -12(sp), r18
        ld.l -16(sp), r19
        ld.l -20(sp), r20
        ld.l -24(sp), r21
        ld.l -28(sp), r22
        ld.l -32(sp), r23
        ld.l -36(sp), r24
        ld.l -40(sp), r25
        ld.l -44(sp), r26
        ld.l -48(sp), r27
        ld.l -52(sp), r28
        ld.l -56(sp), r29
        ld.l -60(sp), r30
        ld.l -64(sp), r1

        mov   r16,  r23 
        //  r23 =malloc(64k)
        st.l  r16, 512( r26 )
        // lcc->next =  r23 
        mov   65532 , r31
        fst.l f0, r31( r23 )
        //  r23 ->next = NULL

.dont_malloc::
        // last_coeffchunk=next,
        //  r22 =next,
        //  r26 =next+65020,

        orh ha%_last_coeffchunk, r0, r31
        st.l   r23 , l%_last_coeffchunk(r31)
        mov  ( 65532 -512), r31
        adds r31,  r23 ,  r26 

.dont_grab_chunk::
        bri r1
        nop

//}}}  

//{{{  opacity_intro(label1, label2)

//}}}  
//{{{  ignore_opacity_intro(label1,label2)

//}}}  
//{{{  next_poly(label)

//}}}  


// /////////////////////////////
// the currently implemented functions
// _tri_zb_rgb
// _tri_zb_rgb_t
// _tri_zb_f
// _tri_zb_f_t
//
//  NOTE the texturing triangle functions now need to compute
//  zscale based on smallest z in triangle, and multiply up
//  z, u and v by this number
//
//  use register  r11  to hold edge opcode, so intro needs to go,
//  if  r11 , opcode=tree_ge_zero, else opcode=tree_lt_zero
//

//
// triangle, z-buffered, flat
//
//{{{  _tri_zb_f

        .globl _tri_zb_f
        .align 8

_tri_zb_f::
         fst.d f2, -8(sp); fst.d f4, -16(sp); fst.d f6, -24(sp); st.l r1, -28(sp); st.l r3, -32(sp); st.l r4, -36(sp); st.l r5, -40(sp); st.l r6, -44(sp); st.l r7, -48(sp); st.l r8, -52(sp); st.l r9, -56(sp); st.l r10, -60(sp); st.l r11, -64(sp); st.l r12, -68(sp); st.l r13, -72(sp); st.l r14, -76(sp); st.l r15, -80(sp); adds -96, sp, sp;   or (  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ; bte 0x0,  r19 ,  back_000 ;   or (  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ;  back_000 :: ; mov  r16 ,  r25 ; mov  r17 ,  r10 ; mov  r18 ,  r24 ; mov  r20 ,  r27 ; fmov.ss  f8 ,  f3 ; ld.l r0( r25 ),  r23 ; orh ha%_last_coeffchunk, r0, r31; ld.l l%_last_coeffchunk(r31),  r26 ; mov ( 65532 -512), r31; adds r31,  r26 ,  r26  
        adds 0, r0,  r21 

//  4  4
//
//  new opacity code
//
          label000 ::;ld.l  (60) ( r24 ), r31;ld.l  4 ( r24 ),   r8  ; bte 0x0, r31,  label001 ; call chunk_fn; ld.l ( 8 +0)( r24 ),   r18  ; adds 12,  r23 ,  r22 ; ld.l ( 8 +4)( r24 ),   r19  ; or   ( 0x100 )  , r0,  r17 ; ld.l ( 8 +8)( r24 ),  r20 ; st.l  r17 , 0( r23 );   or (  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r17 ,  r17   ; st.l  r17 , 4( r23 ); or  ( 0 | (((  52  ) & 0xff) << 0) ) , r0,  r17 ; st.l  r17 , 8( r23 ); st.l  r10 , 12( r23 ) 

        call _preplanarize_fn_p
        adds  (( 48 ) + 8) , r0,  r17 

// should we just exit ?
        xor 0x0, r31, r0
        bnc label001

         or (  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,   r16   
        call edgize_fn
         orh ((  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,   r16  ,   r16   

        call _planarize_fn_p
        or     (( 48 ) + 8) , r0,  r17 

        fld.l  48 ( r24 ),  f25 
        // store 'do zbuffer, no arguments' into coeff store
          or (  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 4( r22 )
        adds 4,  r22 ,  r22 

          or (  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fst.l  f25 , 12( r22 )++

        fld.l  (48+4) ( r24 ),  f25 

          or (  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fst.l  f25 , 12( r22 )++

        fld.l  (48+8) ( r24 ),  f25 

          or (  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fst.l  f25 , 12( r22 )++

          or (  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l   r16 ,   4( r22 )
        fst.l  f3 , 8( r22 )++

        call _safe_binitize_fn
        fst.l f0, 4( r22 )++  // addu 10, r0,  r18 

          label001 ::;adds -1,  r27 ,  r27 ; xor 0x0000,  r27 , r0; bnc.t  label000 ; ld.l 0( r24 ),  r24  

.bomb_tri_zb_f::

         st.l  r23 , 0( r25 ); adds 96, sp, sp; adds 4,  r22 ,  r16 ; ld.l -80(sp), r15; ld.l -76(sp), r14; ld.l -72(sp), r13; ld.l -68(sp), r12; ld.l -64(sp), r11; ld.l -60(sp), r10; ld.l -56(sp), r9; ld.l -52(sp), r8; ld.l -48(sp), r7; ld.l -44(sp), r6; ld.l -40(sp), r5; ld.l -36(sp), r4; ld.l -32(sp), r3; ld.l -28(sp), r1; fld.d -24(sp), f6; fld.d -16(sp), f4; bri r1; fld.d -8(sp), f2 
//}}}  


// triangle, z-buffered, rgb
//
//{{{  _tri_zb_rgb

        .globl _tri_zb_rgb
        .align 8

_tri_zb_rgb::
         fst.d f2, -8(sp); fst.d f4, -16(sp); fst.d f6, -24(sp); st.l r1, -28(sp); st.l r3, -32(sp); st.l r4, -36(sp); st.l r5, -40(sp); st.l r6, -44(sp); st.l r7, -48(sp); st.l r8, -52(sp); st.l r9, -56(sp); st.l r10, -60(sp); st.l r11, -64(sp); st.l r12, -68(sp); st.l r13, -72(sp); st.l r14, -76(sp); st.l r15, -80(sp); adds -96, sp, sp;   or (  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ; bte 0x0,  r19 ,  back_001 ;   or (  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ;  back_001 :: ; mov  r16 ,  r25 ; mov  r17 ,  r10 ; mov  r18 ,  r24 ; mov  r20 ,  r27 ; fmov.ss  f8 ,  f3 ; ld.l r0( r25 ),  r23 ; orh ha%_last_coeffchunk, r0, r31; ld.l l%_last_coeffchunk(r31),  r26 ; mov ( 65532 -512), r31; adds r31,  r26 ,  r26  
        adds 0, r0,  r21 

//  4  4
//
//  new opacity code
//
          label002 ::;ld.l  (60) ( r24 ), r31;ld.l  4 ( r24 ),   r8  ; bte 0x0, r31,  label003 ; call chunk_fn; ld.l ( 8 +0)( r24 ),   r18  ; adds 12,  r23 ,  r22 ; ld.l ( 8 +4)( r24 ),   r19  ; or   ( 0x100 )  , r0,  r17 ; ld.l ( 8 +8)( r24 ),  r20 ; st.l  r17 , 0( r23 );   or (  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r17 ,  r17   ; st.l  r17 , 4( r23 ); or  ( 0 | (((  52  ) & 0xff) << 0) ) , r0,  r17 ; st.l  r17 , 8( r23 ); st.l  r10 , 12( r23 ) 

        call _preplanarize_fn_p
        adds  (( 48 ) + 8) , r0,  r17 

// should we just exit ?
        xor 0x0, r31, r0
        bnc label003

         or (  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,   r16   
        call edgize_fn
         orh ((  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,   r16  ,   r16   

        call _planarize_fn_p
        or     ( 64 ) , r0,  r17 

        // store 'do zbuffer, no arguments' into coeff store
          or (  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 4( r22 )

// 2 23
          or (  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l   r17 ,   8( r22 )
        fst.l  f3 , 12( r22 )++

// 15  38
          or (  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+4) , r0,  r17 

          or (  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+8) , r0,  r17 

          or (  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+8) , r0,  r17 

        //  or (  ( 0x10000000 |( 19 )) )&0xffff, r0,   r17  ; orh ((  ( 0x10000000 |( 19 )) )>>16)&0xffff,   r17  ,   r17   
        //
        // fix_rcoeffptr(19)
        //
        // mov  r23 ,  r16 

        call _safe_binitize_fn
        fst.l f0, 4( r22 )++  // addu 10, r0,  r18 

          label003 ::;adds -1,  r27 ,  r27 ; xor 0x0000,  r27 , r0; bnc.t  label002 ; ld.l 0( r24 ),  r24  
.bomb_tri_zb_rgb::

         st.l  r23 , 0( r25 ); adds 96, sp, sp; adds 4,  r22 ,  r16 ; ld.l -80(sp), r15; ld.l -76(sp), r14; ld.l -72(sp), r13; ld.l -68(sp), r12; ld.l -64(sp), r11; ld.l -60(sp), r10; ld.l -56(sp), r9; ld.l -52(sp), r8; ld.l -48(sp), r7; ld.l -44(sp), r6; ld.l -40(sp), r5; ld.l -36(sp), r4; ld.l -32(sp), r3; ld.l -28(sp), r1; fld.d -24(sp), f6; fld.d -16(sp), f4; bri r1; fld.d -8(sp), f2 
//}}}  

//
// Now the textured triangles
// NB if you need 1 bit of pushed storage during triangle processing,
// use texz LSB, it is dropped before perspective divide...
//
//
// all these functions need the texture rescale
//
//
// triangle, z-buffered, flat, textured
//
//{{{  _tri_zb_f_t

        .globl _tri_zb_f_t
        .align 8

_tri_zb_f_t::
         fst.d f2, -8(sp); fst.d f4, -16(sp); fst.d f6, -24(sp); st.l r1, -28(sp); st.l r3, -32(sp); st.l r4, -36(sp); st.l r5, -40(sp); st.l r6, -44(sp); st.l r7, -48(sp); st.l r8, -52(sp); st.l r9, -56(sp); st.l r10, -60(sp); st.l r11, -64(sp); st.l r12, -68(sp); st.l r13, -72(sp); st.l r14, -76(sp); st.l r15, -80(sp); adds -96, sp, sp;   or (  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ; bte 0x0,  r19 ,  back_002 ;   or (  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ;  back_002 :: ; mov  r16 ,  r25 ; mov  r17 ,  r10 ; mov  r18 ,  r24 ; mov  r20 ,  r27 ; fmov.ss  f8 ,  f3 ; ld.l r0( r25 ),  r23 ; orh ha%_last_coeffchunk, r0, r31; ld.l l%_last_coeffchunk(r31),  r26 ; mov ( 65532 -512), r31; adds r31,  r26 ,  r26  
        adds 1, r0,  r21 


          label004 ::;ld.l  (60) ( r24 ), r31;ld.l  4 ( r24 ),   r8  ; bte 0x0, r31,  label005 ; call chunk_fn; ld.l ( 8 +0)( r24 ),   r18  ; adds 12,  r23 ,  r22 ; ld.l ( 8 +4)( r24 ),   r19  ; or   ( 0x100 )  , r0,  r17 ; ld.l ( 8 +8)( r24 ),  r20 ; st.l  r17 , 0( r23 );   or (  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r17 ,  r17   ; st.l  r17 , 4( r23 ); or  ( 0 | (((  52  ) & 0xff) << 0) ) , r0,  r17 ; st.l  r17 , 8( r23 ); st.l  r10 , 12( r23 ) 

        call _preplanarize_fn_p
        adds  (( 48 ) + 8) , r0,  r17 

// should we just exit ?
        xor 0x0, r31, r0
        bnc label005

         or (  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,   r16   
        call edgize_fn
         orh ((  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,   r16  ,   r16   


// TEXTURIZE TO FIND ZSCALE

         orh ha% _.Cturn_z_to_tex , r0, r31; fld.l l% _.Cturn_z_to_tex (r31),   f29   
        frcp.ss   f2 ,  f28 
        fmul.ss   f28 ,  f29 ,  f28 
        // store 'do zbuffer, no arguments' into coeff store
          or (  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )>>16)&0xffff,  r16 ,  r16   
        fmul.ss   f24 ,  f28 ,  f6 
        st.l  r16 , 20( r22 )
        fmul.ss   f25 ,  f28 ,  f7 
        fmul.ss   f26 ,  f28 ,   f31  
        fmul.ss   f5 ,  f28 ,  f5 

          or (  ( ( 0x422100 | ((( ( ( 97 ) ) ) & 0xff) << 0) | ((((( ( ( 20 ) ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x422100 | ((( ( ( 97 ) ) ) & 0xff) << 0) | ((((( ( ( 20 ) ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     (( 32 )+0) , r0,  r17 

        fmov.ss  f6 ,  f24 
        fmov.ss  f7 ,  f25 
        fmov.ss   f31  ,  f26 

//      push enable flag for texture support
          or (   ( 0xb500 | ((( ( 154 ) ) & 0xff) << 0) )  )&0xffff, r0,  r16  ;  orh ((   ( 0xb500 | ((( ( 154 ) ) & 0xff) << 0) )  )>>16)&0xffff,  r16 ,  r16   ;
        st.l  r16 , 8( r22 )
        adds 8,  r22 ,  r22 

// 4  25  tex z-coordinate
          or (  ( ( 0x24300 | ((( ( ( 32 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 32 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     (( 32 )+0) , r0,  r17 

// fix u-coordinate

         orh ha% _Cdelta_u , r0, r31; fld.l l% _Cdelta_u (r31),   f29   
        pfadd.ss  f29 ,  f24 , f0
        pfadd.ss  f29 ,  f25 , f0
        pfadd.ss  f29 ,  f26 , f0
        pfadd.ss f0, f0,  f24 
        m12apm.ss  f6 ,  f24 ,  f25 
        m12apm.ss  f7 ,  f25 ,  f26 
        pfmul.ss    f31  ,  f26 , f0
        pfmul.ss f0, f0,  f24 
        pfmul.ss f0, f0,  f25 
        pfmul.ss f0, f0,  f26 

// 4 29  tex v-coordinate
          or (  ( ( 0x24300 | ((( ( ( 57 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 57 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     (( 32 )+4) , r0,  r17 

// fix v-coordinate

         orh ha% _Cdelta_v , r0, r31; fld.l l% _Cdelta_v (r31),   f29   
        pfadd.ss  f29 ,  f24 , f0
        pfadd.ss  f29 ,  f25 , f0
        pfadd.ss  f29 ,  f26 , f0
        pfadd.ss f0, f0,  f24 
        m12apm.ss  f6 ,  f24 ,  f25 
        m12apm.ss  f7 ,  f25 ,  f26 
        pfmul.ss    f31  ,  f26 , f0
        pfmul.ss f0, f0,  f24 
        pfmul.ss f0, f0,  f25 
        pfmul.ss f0, f0,  f26 

// 4  33  tex u-coordinate
          or (  ( ( 0x24300 | ((( ( ( 77 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 77 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     (( 48 ) + 8) , r0,  r17 

// do texture dynamic range frig
        call _texture_rescale
        adds 1, r0,  r28 
// 9  42
        fld.l  48 ( r24 ),  f25 
          or (  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fst.l  f25 , 12( r22 )++

        fld.l  (48+4) ( r24 ),  f25 

          or (  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fst.l  f25 , 12( r22 )++

        fld.l  (48+8) ( r24 ),  f25 

          or (  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(1<<18)|(1<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fst.l  f25 , 12( r22 )++


// 2 44
          or (  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l   r16 ,   4( r22 )
        fst.l  f3 , 8( r22 )++

        // adds   22,  r28 ,  r17 
        // orh ( 0x10000000 >>16)&0xffff,  r17 ,  r17 

        // adds   35,  r22 ,  r22 
        // andnot 31,  r22 ,  r22 
        // adds   -4,  r22 ,  r22 

        // mov  r23 ,  r16 

        call _safe_binitize_fn
        fst.l f0, 4( r22 )++  // addu 10, r0,  r18 

          label005 ::;adds -1,  r27 ,  r27 ; xor 0x0000,  r27 , r0; bnc.t  label004 ; ld.l 0( r24 ),  r24  

.bomb_tri_zb_f_t::

         st.l  r23 , 0( r25 ); adds 96, sp, sp; adds 4,  r22 ,  r16 ; ld.l -80(sp), r15; ld.l -76(sp), r14; ld.l -72(sp), r13; ld.l -68(sp), r12; ld.l -64(sp), r11; ld.l -60(sp), r10; ld.l -56(sp), r9; ld.l -52(sp), r8; ld.l -48(sp), r7; ld.l -44(sp), r6; ld.l -40(sp), r5; ld.l -36(sp), r4; ld.l -32(sp), r3; ld.l -28(sp), r1; fld.d -24(sp), f6; fld.d -16(sp), f4; bri r1; fld.d -8(sp), f2 
//}}}  

// triangle, z-buffered, rgb, textured
// 24 64-bit words
//
//{{{  _tri_zb_rgb_t

        .globl _tri_zb_rgb_t
        .align 8

_tri_zb_rgb_t::
         fst.d f2, -8(sp); fst.d f4, -16(sp); fst.d f6, -24(sp); st.l r1, -28(sp); st.l r3, -32(sp); st.l r4, -36(sp); st.l r5, -40(sp); st.l r6, -44(sp); st.l r7, -48(sp); st.l r8, -52(sp); st.l r9, -56(sp); st.l r10, -60(sp); st.l r11, -64(sp); st.l r12, -68(sp); st.l r13, -72(sp); st.l r14, -76(sp); st.l r15, -80(sp); adds -96, sp, sp;   or (  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ; bte 0x0,  r19 ,  back_003 ;   or (  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ;  back_003 :: ; mov  r16 ,  r25 ; mov  r17 ,  r10 ; mov  r18 ,  r24 ; mov  r20 ,  r27 ; fmov.ss  f8 ,  f3 ; ld.l r0( r25 ),  r23 ; orh ha%_last_coeffchunk, r0, r31; ld.l l%_last_coeffchunk(r31),  r26 ; mov ( 65532 -512), r31; adds r31,  r26 ,  r26  
        adds 1, r0,  r21 

//  4  4
//
//  new opacity code
//
          label006 ::;ld.l  (60) ( r24 ), r31;ld.l  4 ( r24 ),   r8  ; bte 0x0, r31,  label007 ; call chunk_fn; ld.l ( 8 +0)( r24 ),   r18  ; adds 12,  r23 ,  r22 ; ld.l ( 8 +4)( r24 ),   r19  ; or   ( 0x100 )  , r0,  r17 ; ld.l ( 8 +8)( r24 ),  r20 ; st.l  r17 , 0( r23 );   or (  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80016c00 | (((( ( ( 5 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r17 ,  r17   ; st.l  r17 , 4( r23 ); or  ( 0 | (((  52  ) & 0xff) << 0) ) , r0,  r17 ; st.l  r17 , 8( r23 ); st.l  r10 , 12( r23 ) 

        call _preplanarize_fn_p
        adds  (( 48 ) + 8) , r0,  r17 

// should we just exit ?
        xor 0x0, r31, r0
        bnc label007

         or (  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,   r16   
        call edgize_fn
         orh ((  ( ( 0x422100 | ((( ( 97 ) ) & 0xff) << 0) | ((((( ( 20 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,   r16  ,   r16   

// TEXTURIZE TO FIND ZSCALE

         orh ha% _.Cturn_z_to_tex , r0, r31; fld.l l% _.Cturn_z_to_tex (r31),   f29   
        frcp.ss   f2 ,  f28 
        fmul.ss   f28 ,  f29 ,  f28 

        pfmul.ss   f24 ,  f28 , f0
        pfmul.ss   f25 ,  f28 , f0
        pfmul.ss   f26 ,  f28 , f0
        pfmul.ss  f0, f0,  f6 
        pfmul.ss  f0, f0,  f7 
        pfmul.ss  f0, f0,   f31  

        call _planarize_fn_p
        or     (( 32 )+0) , r0,  r17 

//      push enable flag for texture support
          or (   ( 0xb500 | ((( ( 154 ) ) & 0xff) << 0) )  )&0xffff, r0,  r16  ;  orh ((   ( 0xb500 | ((( ( 154 ) ) & 0xff) << 0) )  )>>16)&0xffff,  r16 ,  r16   ;
        st.l  r16 , 4( r22 )

          or (  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fmov.ss  f6 ,  f24 
        adds 8,  r22 ,  r22    // cater for tree_l0 and enable push

        fmov.ss  f7 ,  f25 
          or (  ( ( 0x24300 | ((( ( ( 32 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 32 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        fmov.ss   f31  ,  f26 

// 4  25  tex z-coordinate
        call _planarize_fn_p
        or     (( 32 )+0) , r0,  r17 

// fix u-coordinate

// fix v-coordinate

         orh ha% _Cdelta_u , r0, r31; fld.l l% _Cdelta_u (r31),   f29   
        pfadd.ss  f29 ,  f24 , f0
        pfadd.ss  f29 ,  f25 , f0
        pfadd.ss  f29 ,  f26 , f0
        pfadd.ss f0, f0,  f24 
        m12apm.ss  f6 ,  f24 ,  f25 
        m12apm.ss  f7 ,  f25 ,  f26 
        pfmul.ss    f31  ,  f26 , f0
        pfmul.ss f0, f0,  f24 
        pfmul.ss f0, f0,  f25 
        pfmul.ss f0, f0,  f26 

// 4  29  tex v-coordinate
          or (  ( ( 0x24300 | ((( ( ( 57 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 57 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     (( 32 )+4) , r0,  r17 

// fix v-coordinate

// fix v-coordinate

         orh ha% _Cdelta_v , r0, r31; fld.l l% _Cdelta_v (r31),   f29   
        pfadd.ss  f29 ,  f24 , f0
        pfadd.ss  f29 ,  f25 , f0
        pfadd.ss  f29 ,  f26 , f0
        pfadd.ss f0, f0,  f24 
        m12apm.ss  f6 ,  f24 ,  f25 
        m12apm.ss  f7 ,  f25 ,  f26 
        pfmul.ss    f31  ,  f26 , f0
        pfmul.ss f0, f0,  f24 
        pfmul.ss f0, f0,  f25 
        pfmul.ss f0, f0,  f26 

// 4  33  tex u-coordinate
          or (  ( ( 0x24300 | ((( ( ( 77 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 77 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     ( 64 ) , r0,  r17 

// do texture dynamic range frig
        call _texture_rescale
        adds 1, r0,  r28 

// 2 35
          or (  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l   r16 ,   4( r22 )
        fst.l  f3 , 8( r22 )++

// 15  50
          or (  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+4) , r0,  r17 

          or (  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+8) , r0,  r17 

          or (  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+8) , r0,  r17 

        // adds 25,  r28 ,  r17 
        // orh ( 0x10000000 >>16)&0xffff,  r17 ,  r17 

        // adds   35,  r22 ,  r22 
        // andnot 31,  r22 ,  r22 
        // adds   -4,  r22 ,  r22 

        // mov  r23 ,  r16 

        call _safe_binitize_fn
        fst.l f0, 4( r22 )++  // addu 10, r0,  r18 

          label007 ::;adds -1,  r27 ,  r27 ; xor 0x0000,  r27 , r0; bnc.t  label006 ; ld.l 0( r24 ),  r24  
.bomb_tri_zb_rgb_t::

         st.l  r23 , 0( r25 ); adds 96, sp, sp; adds 4,  r22 ,  r16 ; ld.l -80(sp), r15; ld.l -76(sp), r14; ld.l -72(sp), r13; ld.l -68(sp), r12; ld.l -64(sp), r11; ld.l -60(sp), r10; ld.l -56(sp), r9; ld.l -52(sp), r8; ld.l -48(sp), r7; ld.l -44(sp), r6; ld.l -40(sp), r5; ld.l -36(sp), r4; ld.l -32(sp), r3; ld.l -28(sp), r1; fld.d -24(sp), f6; fld.d -16(sp), f4; bri r1; fld.d -8(sp), f2 
//}}}  

// triangle, z-buffered, rgb, textured, opacity-per-vertex
// 24 64-bit words
//
//{{{  _tri_zb_rgb_o_t

        .globl _tri_zb_rgb_o_t
        .align 8

_tri_zb_rgb_o_t::
         fst.d f2, -8(sp); fst.d f4, -16(sp); fst.d f6, -24(sp); st.l r1, -28(sp); st.l r3, -32(sp); st.l r4, -36(sp); st.l r5, -40(sp); st.l r6, -44(sp); st.l r7, -48(sp); st.l r8, -52(sp); st.l r9, -56(sp); st.l r10, -60(sp); st.l r11, -64(sp); st.l r12, -68(sp); st.l r13, -72(sp); st.l r14, -76(sp); st.l r15, -80(sp); adds -96, sp, sp;   or (  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x414200 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ; bte 0x0,  r19 ,  back_004 ;   or (  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r11  ;  orh ((  ( ( 0x400d00 | ((((2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r11 ,  r11   ;  back_004 :: ; mov  r16 ,  r25 ; mov  r17 ,  r10 ; mov  r18 ,  r24 ; mov  r20 ,  r27 ; fmov.ss  f8 ,  f3 ; ld.l r0( r25 ),  r23 ; orh ha%_last_coeffchunk, r0, r31; ld.l l%_last_coeffchunk(r31),  r26 ; mov ( 65532 -512), r31; adds r31,  r26 ,  r26  
        adds 1, r0,  r21 

//  1  1
//
//  new opacity code
//
// destination for per-triangle loop - what registers are still in shape?

          label008 ::;ld.l  (60) ( r24 ), r31;ld.l  4 ( r24 ),   r8  ; bte 0x0, r31,  label009 ; call chunk_fn; ld.l ( 8 +0)( r24 ),   r18  ; adds 0,  r23 ,  r22 ; ld.l ( 8 +4)( r24 ),   r19  ; or   ( 0x100 )  , r0,  r17 ; ld.l ( 8 +8)( r24 ),  r20 ; st.l  r17 , 0( r22 ) 

        call _preplanarize_fn_p
        adds  (( 32 )+8) , r0,  r17 

// should we just exit ?
        xor 0x0, r31, r0
        bnc label009

         or (  ( ( 0x422800 | ((( ( 52 ) ) & 0xff) << 0) | ((((( ( 5 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,   r16   
        call edgize_fn
         orh ((  ( ( 0x422800 | ((( ( 52 ) ) & 0xff) << 0) | ((((( ( 5 ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,   r16  ,   r16   


        call _planarize_fn_p
        or     (( 48 ) + 8) , r0,  r17 

          or (  ( ( 0x422100 | ((( ( ( 97 ) ) ) & 0xff) << 0) | ((((( ( ( 20 ) ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x422100 | ((( ( ( 97 ) ) ) & 0xff) << 0) | ((((( ( ( 20 ) ) )+2)+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   

// 5  22
// TEXTURIZE TO FIND ZSCALE

         orh ha% _.Cturn_z_to_tex , r0, r31; fld.l l% _.Cturn_z_to_tex (r31),   f29   
        frcp.ss   f2 ,  f28 
        fmul.ss   f28 ,  f29 ,  f28 

        pfmul.ss   f24 ,  f28 , f0
        pfmul.ss   f25 ,  f28 , f0
        pfmul.ss   f26 ,  f28 , f0
        pfmul.ss  f0, f0,  f6 
        pfmul.ss  f0, f0,  f7 
        pfmul.ss  f0, f0,   f31  

        call _planarize_fn_p
        or     (( 32 )+0) , r0,  r17 

//      push enable flag for texture support
          or (   ( 0xb500 | ((( ( 154 ) ) & 0xff) << 0) )  )&0xffff, r0,  r16  ;  orh ((   ( 0xb500 | ((( ( 154 ) ) & 0xff) << 0) )  )>>16)&0xffff,  r16 ,  r16   ;
        st.l  r16 , 4( r22 )

          or (  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 97 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(0<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l  r16 , 8( r22 )
        fmov.ss  f6 ,  f24 
        adds 8,  r22 ,  r22    // cater for tree_l0 and enable push

        fmov.ss  f7 ,  f25 
          or (  ( ( 0x24300 | ((( ( ( 32 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 32 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        fmov.ss   f31  ,  f26 

// 4  26  tex z-coordinate
        call _planarize_fn_p
        or     (( 32 )+0) , r0,  r17 

// fix u-coordinate

// fix v-coordinate

         orh ha% _Cdelta_u , r0, r31; fld.l l% _Cdelta_u (r31),   f29   
        pfadd.ss  f29 ,  f24 , f0
        pfadd.ss  f29 ,  f25 , f0
        pfadd.ss  f29 ,  f26 , f0
        pfadd.ss f0, f0,  f24 
        m12apm.ss  f6 ,  f24 ,  f25 
        m12apm.ss  f7 ,  f25 ,  f26 
        pfmul.ss    f31  ,  f26 , f0
        pfmul.ss f0, f0,  f24 
        pfmul.ss f0, f0,  f25 
        pfmul.ss f0, f0,  f26 

// 4  30  tex v-coordinate
          or (  ( ( 0x24300 | ((( ( ( 57 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 57 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     (( 32 )+4) , r0,  r17 

// fix v-coordinate

// fix v-coordinate

         orh ha% _Cdelta_v , r0, r31; fld.l l% _Cdelta_v (r31),   f29   
        pfadd.ss  f29 ,  f24 , f0
        pfadd.ss  f29 ,  f25 , f0
        pfadd.ss  f29 ,  f26 , f0
        pfadd.ss f0, f0,  f24 
        m12apm.ss  f6 ,  f24 ,  f25 
        m12apm.ss  f7 ,  f25 ,  f26 
        pfmul.ss    f31  ,  f26 , f0
        pfmul.ss f0, f0,  f24 
        pfmul.ss f0, f0,  f25 
        pfmul.ss f0, f0,  f26 

// 4  34  tex u-coordinate
          or (  ( ( 0x24300 | ((( ( ( 77 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0x24300 | ((( ( ( 77 ) ) ) & 0xff) << 0) | (((( ( ( 20 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r16 ,  r16   
        call _planarize_fn_p
        or     ( 64 ) , r0,  r17 

// do texture dynamic range frig
        call _texture_rescale
        adds 1, r0,  r28 

// 2 36
          or (  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )&0xffff, r0,  r16  ;  orh ((  ( ( 0xf700 | ((( ( ( 141 ) ) ) & 0xff) << 0) | (((( ( ( 13 ) ) )+116) & 0x7f) << 23) ) |(1<<20)) )>>16)&0xffff,  r16 ,  r16   
        st.l   r16 ,   4( r22 )
        fst.l  f3 , 8( r22 )++

// 15  51
          or (  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 117 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+4) , r0,  r17 

          or (  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 125 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+8) , r0,  r17 

          or (  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )&0xffff, r0,  r17  ;  orh ((  ( ( 0x80435a00 | ((( ( ( 133 ) ) ) & 0xff) << 0) | (((( ( ( 8 ) ) )+115) & 0xff) << 23) ) |(2<<18)|(2<<20)) )>>16)&0xffff,  r17 ,  r17   
        st.l  r17 , 4( r22 )
        adds 4,  r22 ,  r22 
          or (  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )&0xffff, r0,  r16  ;  orh ((  ( 0 | ((( ( ( 8 ) ) ) & 0x7f) << 16) ) )>>16)&0xffff,  r16 ,  r16   

        call _planarize_fn_p
        or     (( 64 )+8) , r0,  r17 
        // fst.l f0, 4( r22 )++

        // adds 26,  r28 ,  r17 
        // orh ( 0x10000000 >>16)&0xffff,  r17 ,  r17 

        // adds   35,  r22 ,  r22 
        // andnot 31,  r22 ,  r22 
        // adds   -4,  r22 ,  r22 

        // mov  r23 ,  r16 

        call _safe_binitize_fn
        fst.l f0, 4( r22 )++  // addu 10, r0,  r18 

          label009 ::;adds -1,  r27 ,  r27 ; xor 0x0000,  r27 , r0; bnc.t  label008 ; ld.l 0( r24 ),  r24  
.bomb_tri_zb_rgb_o_t::

         st.l  r23 , 0( r25 ); adds 96, sp, sp; adds 4,  r22 ,  r16 ; ld.l -80(sp), r15; ld.l -76(sp), r14; ld.l -72(sp), r13; ld.l -68(sp), r12; ld.l -64(sp), r11; ld.l -60(sp), r10; ld.l -56(sp), r9; ld.l -52(sp), r8; ld.l -48(sp), r7; ld.l -44(sp), r6; ld.l -40(sp), r5; ld.l -36(sp), r4; ld.l -32(sp), r3; ld.l -28(sp), r1; fld.d -24(sp), f6; fld.d -16(sp), f4; bri r1; fld.d -8(sp), f2 
//}}}  

























































































































































































































































































































































//{{{  _reg_dump
        .globl _reg_dump
        .align 8

_reg_dump::
        //{{{  proc entry - save r1 r2 r3
        addu -256, sp, sp
        st.l r1,0(sp)
        adds 256,sp,r1
        // save r2  **before** call into stack frame
        st.l r1,4(sp)
        st.l fp,8(sp)
        //}}}  
        //{{{  save r4..r31, f2..f31
        st.l r4,  12(sp)
        st.l r5,  16(sp)
        st.l r6,  20(sp)
        st.l r7,  24(sp)
        st.l r8,  28(sp)
        st.l r9,  32(sp)
        st.l r10, 36(sp)
        st.l r11, 40(sp)
        st.l r12, 44(sp)
        st.l r13, 48(sp)
        st.l r14, 52(sp)
        st.l r15, 56(sp)
        st.l r16, 60(sp)
        //st.l r17, 64(sp)
        st.l r18, 68(sp)
        st.l r19, 72(sp)
        st.l r20, 76(sp)
        st.l r21, 80(sp)
        st.l r22, 84(sp)
        st.l r23, 88(sp)
        st.l r24, 92(sp)
        st.l r25, 96(sp)
        st.l r26, 100(sp)
        st.l r27, 104(sp)
        st.l r28, 108(sp)
        st.l r29, 112(sp)
        st.l r30, 116(sp)
        st.l r31, 120(sp)
        adds 120, sp, sp
        fst.l f2, 4(sp)++
        fst.l f3, 4(sp)++
        fst.l f4, 4(sp)++
        fst.l f5, 4(sp)++
        fst.l f6, 4(sp)++
        fst.l f7, 4(sp)++
        fst.l f8, 4(sp)++
        fst.l f9, 4(sp)++
        fst.l f10, 4(sp)++
        fst.l f11, 4(sp)++
        fst.l f12, 4(sp)++
        fst.l f13, 4(sp)++
        fst.l f14, 4(sp)++
        fst.l f15, 4(sp)++
        fst.l f16, 4(sp)++
        fst.l f17, 4(sp)++
        fst.l f18, 4(sp)++
        fst.l f19, 4(sp)++
        fst.l f20, 4(sp)++
        fst.l f21, 4(sp)++
        fst.l f22, 4(sp)++
        fst.l f23, 4(sp)++
        fst.l f24, 4(sp)++
        fst.l f25, 4(sp)++
        fst.l f26, 4(sp)++
        fst.l f27, 4(sp)++
        fst.l f28, 4(sp)++
        fst.l f29, 4(sp)++
        fst.l f30, 4(sp)++
        fst.l f31, 4(sp)++
        adds -240, sp, sp
        //}}}  
        call _trace_regs
        mov sp, r16
        //{{{  restore all
        ld.l 12(sp) , r4
        ld.l 16(sp) , r5
        ld.l 20(sp) , r6
        ld.l 24(sp) , r7
        ld.l 28(sp) , r8
        ld.l 32(sp) , r9
        ld.l 36(sp) , r10
        ld.l 40(sp) , r11
        ld.l 44(sp) , r12
        ld.l 48(sp) , r13
        ld.l 52(sp) , r14
        ld.l 56(sp) , r15
        ld.l 60(sp) , r16
        ld.l 64(sp) , r17
        ld.l 68(sp) , r18
        ld.l 72(sp) , r19
        ld.l 76(sp) , r20
        ld.l 80(sp) , r21
        ld.l 84(sp) , r22
        ld.l 88(sp) , r23
        ld.l 92(sp) , r24
        ld.l 96(sp) , r25
        ld.l 100(sp) , r26
        ld.l 104(sp) , r27
        ld.l 108(sp) , r28
        ld.l 112(sp) , r29
        ld.l 116(sp) , r30
        ld.l 120(sp) , r31
        adds 120, sp, sp
        fld.l 4(sp)++, f2
        fld.l 4(sp)++, f3
        fld.l 4(sp)++, f4
        fld.l 4(sp)++, f5
        fld.l 4(sp)++, f6
        fld.l 4(sp)++, f7
        fld.l 4(sp)++, f8
        fld.l 4(sp)++, f9
        fld.l 4(sp)++, f10
        fld.l 4(sp)++, f11
        fld.l 4(sp)++, f12
        fld.l 4(sp)++, f13
        fld.l 4(sp)++, f14
        fld.l 4(sp)++, f15
        fld.l 4(sp)++, f16
        fld.l 4(sp)++, f17
        fld.l 4(sp)++, f18
        fld.l 4(sp)++, f19
        fld.l 4(sp)++, f20
        fld.l 4(sp)++, f21
        fld.l 4(sp)++, f22
        fld.l 4(sp)++, f23
        fld.l 4(sp)++, f24
        fld.l 4(sp)++, f25
        fld.l 4(sp)++, f26
        fld.l 4(sp)++, f27
        fld.l 4(sp)++, f28
        fld.l 4(sp)++, f29
        fld.l 4(sp)++, f30
        fld.l 4(sp)++, f31
        adds -240, sp, sp
        
        //}}}  
        //{{{  proc exit
        ld.l 0(sp),r1
        ld.l 8(sp),fp
        bri r1
        addu 256, sp, sp
        //}}}  
//}}}  


// constant for 1/x code
        .data
        .align  8

        .globl _Cmax_x
        .globl _Cmax_y
        .globl _Cdelta_u
        .globl _Cdelta_v

_Cdelta_u:
        .long   0x0
_Cdelta_v:
        .long   0x0

_Cmax_x:        // (0)
.Cmax_x:        // (0)
.C640:
        .long   0x442fbf5c      // 7.02989990E+02

_Cmax_y:        // (0)
.Cmax_y:        // (0)
.C480:
        .long   0x43ff7eb8      // 5.10989990E+02

.fminus_one:
        .long   0xbf800000      // -1.00000000E+00

.fminus_256:
        .long   0xc37ffd71      // -2.55990005E+02

.C00037:        // (0)
.two_point_0:        // (0)
        .long   0x40000000      // 2.00000000E+00

.eight_point_0:        // (0)
        .long   0x41000000      // 8.00000000E+00

.four_point_0:        // (0)
        .long   0x40800000      // 4.00000000E+00

.C362436:        // (0)
        .long   0x3ecccccd      // 4.00000006E-01

//.Czscale1024:        // (0)
//        .long   0x49800000      // 1.04857600E+06

.Czscale:        // (0)
        .long   0x497fffff      // 1.04857588E+06

.Ctexscale:        // (0)
        .long   0x477fffff      // 6.55359883E+04

_.Cturn_z_to_tex:        // (0)
        // .long   0x4879999a      // 2.55590406E+05
        .long   0x48f99980      // 5.11180000E+05

// NB this is now by 4 !!!!!
_.Cturn_z_to_tex_by_4:        // (0)
        .long   0x47f99980      // 1.27795000E+05

_.Cturn_z_to_tex_by_8:        // (0)
        .long   0x4779999a      // 6.38976016E+04

.r5r6r7opcodes:
        .string "r5 r6 r7 have opcodes?"
        .byte 0x0

.done_opacity_intro:
        .string "done opacity intro"
        .byte 0x0

 .have_binitized:
        .string "have binitized, about to go next_triangle"
        .byte 0x0

.run_out_of_coeffs:
        .string "run out of coeffstore"
        .byte 0x0

.bini_pipe_minimax:
        .string "computed minimax piped"
        .byte 0x0