//{{{  stuff
//
//   The plan is to build up a library of often-used and highly
//   optimised i860 assembler functions in here.
//
//   So typically,
//      homogeneous transformers,
//      matrix concatenators,
//      matrix inverters,
//      equation solvers (e.g point/plane intersectors)
//
//   will eventually be put in here and tweaked to hell.
//

//}}}  

        .align 8
        .text



#if 0
//{{{  hm - not much used in here
//{{{  fn_plane_term
        .globl _fn_plane_term
        .align 8

#define ay f8
#define by f9
#define cy f10
#define az f11
#define bz f12
#define cz f13

#define tmp1 f11
#define tmp2 f12
#define tmp3 f13

_fn_plane_term::
        pfsub.ss az, bz, f0      //    az-bz      ?      ?
        pfsub.ss bz, cz, f0      //    bz-cz    az-bz    ?
        pfsub.ss cz, az, f0      //    cz-az    bz-cz  az-bz

        pfsub.ss f0, f0, tmp1    //    trash    cz-az  bz-cz     tmp1=az-bz
        
        m12apm.ss tmp1, cy, tmp2  //    cy*... trash  cz-az     tmp2=bz-cz
        m12apm.ss tmp2, ay, tmp1  //    ay*... cy*... trash     tmp1=cz-az
        m12apm.ss tmp1, by, f0    //    by*... ay*... cy*...
        mm12tpm.ss f0, f0, tmp1    //                         tmp1=cy* ...
        mm12tpm.ss f0, f0, tmp2    //                         tmp2=ay* ...
        mim1p2.ss tmp2, tmp1, tmp3 // tmp1+tmp2               tmp3=by*...
        pfadd.ss f0,f0,f0        //  ??   tmp1+tmp2 ??
        pfadd.ss f0,f0,f0        //  ??       ??    tmp1+tmp2
        pfadd.ss f0,f0,tmp2      //  ??       ??    ??    tmp2=tmp1+tmp2
        bri r1
        fadd.ss tmp3,tmp2,f8


#undef ay
#undef by
#undef cy
#undef az
#undef bz
#undef cz

#undef tmp1
#undef tmp2
#undef tmp3

//}}}  


//{{{  fn_invert  ?
        .globl _fn_invert
        .align 8

_fn_invert::



//}}}  

//{{{  fn_renorm
        .globl _fn_renorm
        .align 8


// r16 holds matrix to renormalise
// r17 holds -1
// r18 holds loop count
// r19 r20 r21 r22 hold 4 temps (for page-mode access)
// r23 holds IEEE exponent mask

_fn_renorm::

     adds -1, r0, r17
     adds 3, r0, r18
     bla r17,r18,.renorm_loop
     orh 0x7f80, r0, r23

.renorm_loop::
     ld.l 0(r16), r19
     ld.l 4(r16), r20
     ld.l 8(r16), r21
     ld.l 12(r16), r22

     and r19,r23,r0
     bnc .renorm0
     st.l r0, 0(r16)
.renorm0::

     and r20,r23,r0
     bnc .renorm1
     st.l r0, 4(r16)
.renorm1::

     and r21,r23,r0
     bnc .renorm2
     st.l r0, 8(r16)
.renorm2::

     and r22,r23,r0
     bnc .renorm3
     st.l r0, 12(r16)
.renorm3::

     bla r17,r18,.renorm_loop
     addu 16,r16,r16

     bri r1
     nop





//}}}  
//}}}  
#endif
//{{{  fn_bbox_plane
// This is just a very good piece of compiler
// output which I have hand-tweaked and saved for posterity
// I cannot believe the compiler did this ...

        .globl _fn_bbox_plane
        .align 8
_fn_bbox_plane:

// lineno: 0
        adds -1, r0, r18
// lineno: 190
        fld.l r0(r17), f11
        fld.l 4(r17), f12
        fld.l 8(r17), f13
        fld.l 12(r17), f14
        mov r16, r21
        adds 1, r0, r19
        addu -12, r16, r26
        addu -8, r16, r27
        mov r0, r16
        bla r18, r19,.B1088
        pfmul.dd f0, f0, f0
// lineno: 201
.B1088: //.M0000
.align 8
        d.pfadd.dd  f0,  f0,  f0
                nop
.align 8
.PD0.B1088105:
        d.fnop
                mov r26, r29
.DB.B10881088:  
        d.fnop
                fld.l 16(r29)++, f17
        d.fnop
                fld.l 16(r29)++, f18
        d.fnop
                fld.l 16(r29)++, f19
        d.fnop
                addu 16, r29, r26
        d.fnop
                fld.l r0(r26), f9
        d.pfmul.ss f19, f12, f0
                mov r21, r30
        d.pfmul.ss f0, f0, f0
                mov r30, r22
        d.pfmul.ss f9, f12, f0
                fld.l 16(r30)++, f23
        d.pfmul.ss f0, f0, f21
                fld.l 16(r30)++, f24
        d.pfmul.ss f0, f0, f0
                fld.l r0(r22), f25
        d.pfmul.ss f0, f0, f20
                fld.l 16(r30)++, f10
        d.pfmul.ss f24, f11, f0
                mov r27, r23
        d.pfmul.ss f0, f0, f0
                fld.l 16(r23)++, f29
        d.pfmul.ss f10, f11, f0
                fld.l 16(r23)++, f30
        d.mi2p1.ss f21, f0, f16
                fld.l 16(r23)++, f31
        d.mm12msm.ss f18, f12, f0
                addu 16, r23, r27
        d.mi2p1.ss f20, f0, f26
                fld.l r0(r27), f8
        d.m12tpa.ss f31, f13, f19
                addu 16, r30, r21
        d.mm12msm.ss f23, f11, f26
                nop
        d.m12tpa.ss f8, f13, f27
                nop
        d.mi2p1.ss f19, f0, f24
                nop
        d.mi2p1.ss f26, f0, f18
                nop
        d.mi2p1.ss f27, f0, f15
                nop
        d.pfadd.ss f14, f16, f16
                nop
        d.m12tpa.ss f30, f13, f20
                nop
        d.ia1p2.ss f14, f28, f28
                nop
        d.ia1p2.ss f0, f0, f21
                nop
        d.mm12msm.ss f0, f0, f31
                nop
        d.pfadd.ss f0, f0, f22
                nop
        d.pfgt.ss f22, f0, f0
                nop
        d.fnop
                bnc ..L3
        d.fnop
                adds 1, r16, r16
..L3:
        
        d.pfgt.ss f21, f0, f0
                nop
        d.fnop
                bnc ..L2
        d.fnop
                adds 1, r16, r16
..L2:
        
        d.pfadd.ss f20, f31, f0
                nop
        d.mm12msm.ss f25, f11, f0
                nop
        d.mm12msm.ss f17, f12, f0
                nop
        d.ia1p2.ss f14, f23, f23
                nop
        d.mm12msm.ss f0, f0, f19
                nop
        d.mm12msm.ss f0, f0, f18
                nop
        d.pfadd.ss f0, f0, f24
                nop
        d.pfgt.ss f24, f0, f0
                nop
        d.fnop
                bnc ..L1
        d.fnop
                adds 1, r16, r16
..L1:
        
        d.pfadd.ss f19, f18, f0
                nop
        d.mm12msm.ss f29, f13, f0
                nop
        d.mm12msm.ss f0, f0, f0
                nop
        d.ia1p2.ss f0, f0, f26
                nop
        d.mi2p1.ss f26, f0, f15
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f14, f27, f27
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f0, f0, f16
                nop
        d.pfgt.ss f16, f0, f0
                nop
        d.fnop
                bnc ..L0
        d.fnop
                adds 1, r16, r16
..L0:
        d.fnop
                bla r18, r19, .DB.B10881088
        d.fnop
                mov r26, r29
        fnop
                bri r1
        fnop
                nop
// lineno: 0
//}}}  

//{{{  p_memcpy
//
// p_memcpy
//
// uses pflds to load - use for copying tristrips from database to
// scratchpad - N.B does NOT cache the source
//
// must be given at least 32 bytes to copy or will fall over
//
//              assumes .double aligned data
//
        .globl _p_memcpy
        .align 8

#define dst   r16
#define src   r17
#define bytes r18
#define itemp r19

_p_memcpy::
          or    -1,r0,itemp      // decrement by 1
          addu   7,bytes,bytes   // copy up to and including a double
          shr    3,bytes,bytes   // correct for sizeof double
          adds  -1,bytes,bytes   // correct for bla
          adds  -8,src,src       // correct for autoincrement

          bla itemp,bytes,.L666666
          adds -8,dst,dst       // and again
.L666666:
          fld.d 8(src)++,f16
          bla itemp,bytes,.L666666
          fst.d f16,8(dst)++

          bri r1
          nop

#undef dst
#undef src
#undef bytes

//}}}  



//{{{  matrix_copy
//
// matrix_copy
//
//              assumes .double aligned data
//
        .globl _matrix_copy
        .align 8

_matrix_copy::
          fld.l  0(r17),  f8
          fld.l  4(r17),  f9
          fld.l  8(r17),  f10
          fld.l  12(r17), f11
          fld.l  16(r17), f12
          fld.l  20(r17), f13
          fld.l  24(r17), f14
          fld.l  28(r17), f15
          fld.l  32(r17), f16
          fld.l  36(r17), f17
          fld.l  40(r17), f18
          fld.l  44(r17), f19
          fld.l  48(r17), f20
          fld.l  52(r17), f21
          fld.l  56(r17), f22
          fld.l  60(r17), f23

          fst.d   f8, 0(r16)
          fst.d  f10, 8(r16)
          fst.d  f12, 16(r16)
          fst.d  f14, 24(r16)
          fst.d  f16, 32(r16)
          fst.d  f18, 40(r16)
          fst.d  f20, 48(r16)
          bri r1
          fst.d  f22, 56(r16)
//}}}  


//{{{  matrix registers

#define m00 f8
#define m01 f9
#define m02 f10
#define m03 f11
#define m10 f12
#define m11 f13
#define m12 f14
#define m13 f15
#define m20 f16
#define m21 f17
#define m22 f18
#define m23 f19
#define m30 f20
#define m31 f21
#define m32 f22
#define m33 f23

#define px  f24
#define py  f25
#define pz  f26
#define pw  f27

#define tmp1 f28
#define tmp2 f29
#define tmp3 f30
#define tmp4 f31
#define tmp5 f7

//}}}  

//{{{  fn_cache_mtx
        .align 8

_fn_cache_mtx::
        adds -4,r16,r31
        fld.l 4(r31)++, m00
        fld.l 4(r31)++, m01
        fld.l 4(r31)++, m02
        fld.l 4(r31)++, m03
        fld.l 4(r31)++, m10
        fld.l 4(r31)++, m11
        fld.l 4(r31)++, m12
        fld.l 4(r31)++, m13
        fld.l 4(r31)++, m20
        fld.l 4(r31)++, m21
        fld.l 4(r31)++, m22
        fld.l 4(r31)++, m23
        fld.l 4(r31)++, m30
        fld.l 4(r31)++, m31
        fld.l 4(r31)++, m32
        bri r1
        fld.l 4(r31)++, m33
//}}}  

//{{{  fn_cache_opt_mtx
        .align 8

_fn_cache_opt_mtx::
        adds -4,r16,r31
        fld.l 4(r31)++, m00
        fld.l 4(r31)++, m01
        fld.l 4(r31)++, m02
        fld.l 8(r31)++, m10
        fld.l 4(r31)++, m11
        fld.l 4(r31)++, m12
        fld.l 8(r31)++, m20
        fld.l 4(r31)++, m21
        fld.l 4(r31)++, m22
        fld.l 8(r31)++, m30
        fld.l 4(r31)++, m31
        bri r1
        fld.l 4(r31)++, m32
//}}}  

//{{{  fn_cache_mtx
        .align 8

_fn_cache_mtxd::
        adds -8,r16,r31
        fld.d 8(r31)++, m00
        fld.d 8(r31)++, m02
        fld.d 8(r31)++, m10
        fld.d 8(r31)++, m12
        fld.d 8(r31)++, m20
        fld.d 8(r31)++, m22
        fld.d 8(r31)++, m30
        bri r1
        fld.d 8(r31)++, m32
//}}}  

//{{{  fn_cache_opt_mtx
        .align 8

_fn_cache_opt_mtxd::
        adds -8,r16,r31
        fld.d 8(r31)++, m00
        fld.d 8(r31)++, m02
        fld.d 8(r31)++, m10
        fld.d 8(r31)++, m12
        fld.d 8(r31)++, m20
        fld.d 8(r31)++, m22
        fld.d 8(r31)++, m30
        bri r1
        fld.d 8(r31)++, m32
//}}}  

//{{{  fn_xform           in 43 ticks
//
//  #define fullxform(d,s)                               \
//    sx =*s++; sy =*s++; sz =*s++; sw=*s++;             \
//    *d++ = (sx*m00) + (sy*m10) + (sz*m20) + (sw*m30);  \
//    *d++ = (sx*m01) + (sy*m11) + (sz*m21) + (sw*m31);  \
//    *d++ = (sx*m02) + (sy*m12) + (sz*m22) + (sw*m32);  \
//    *d++ = (sx*m03) + (sy*m13) + (sz*m23) + (sw*m33)
//
//    matrix held in m11 .. m44
//    r16 points to destn
//    r17 points at the point to transform,
//

        .align 8

_fn_xform::

       fld.l 0(r17),px
       fld.l 4(r17),py
       fld.l 8(r17),pz

       pfmul.ss px,m00,f0
       fld.l 12(r17),pw
       pfmul.ss py,m10,f0
       pfmul.ss pz,m20,f0
       pfmul.ss pw,m30,tmp1
       pfmul.ss px,m01,tmp2
       pfadd.ss tmp1,tmp2,f0    // adder 1 = x00+y10
       pfmul.ss py,m11,tmp1
       pfmul.ss pz,m21,tmp2
       pfadd.ss tmp1,tmp2,f0    // adder 1 = z20 + w30
       pfmul.ss pw,m31,tmp1
       pfmul.ss px,m02,tmp2
       pfadd.ss tmp1,tmp2,f0    // adder 1 = x01+y11
       pfmul.ss py,m12,tmp1
       pfmul.ss pz,m22,tmp2
       pfadd.ss tmp1,tmp2,tmp3  // adder1 = z21+w31   tmp3=x00+y10
       pfmul.ss pw,m32,tmp1
       pfmul.ss px,m03,tmp2
       pfadd.ss tmp1,tmp2,tmp4  // adder1 = x02+y12   tmp4=z20+w30
       pfmul.ss py,m13,tmp1
       pfmul.ss pz,m23,tmp2
       pfadd.ss tmp1,tmp2,tmp5  // adder1 = z22+w32   tmp5=x01+y11
       pfmul.ss pw,m33,tmp1
       pfmul.ss f0,f0,tmp2
       pfadd.ss tmp1,tmp2,px    // adder1 = x03+y13   px=z21+w31
       pfmul.ss f0,f0,tmp1
       pfmul.ss f0,f0,tmp2
       pfadd.ss tmp1,tmp2,py    // adder1=z23+w33     py=x02+y12
       pfadd.ss tmp3,tmp4,tmp1  // adder1=rx          tmp1=z22+w32
       pfadd.ss tmp5,px,tmp2    // adder1=ry          tmp2=x03+y13
       pfadd.ss tmp1,py,tmp3    // adder1=rz          tmp3=z23+w33
       pfadd.ss tmp2,tmp3,px
       fst.l px, 0(r16)
       pfadd.ss f0,f0,py
       fst.l py, 4(r16)
       pfadd.ss f0,f0,pz
       fst.l pz, 8(r16)
       pfadd.ss f0,f0,pw
       bri r1
       fst.l pw, 12(r16)      // total 43 ticks

//}}}  

//{{{  fn_optxform        in 28 ticks
//
//  only called on vertices, which are quad-aligned
//
//  #define optxform(s,d)                               \
//    sx =*s++; sy =*s++; sz =*s++; sw=*s++;             \
//    *d++ = (sx*m00) + (sy*m10) + (sz*m20) + m30;  \
//    *d++ = (sx*m01) + (sy*m11) + (sz*m21) + m31;  \
//    *d++ = (sx*m02) + (sy*m12) + (sz*m22) + m32;  \
//    *d++ = 1
//
//    matrix held in m11 .. m44
//    r16 points to destn
//    r17 points at the point to transform,
//

        .align 8

_fn_optxform::

       fld.l 0(r17),px
       fld.l 4(r17),py

       pfmul.ss px,m00,f0
       fld.l 8(r17),pz
       pfmul.ss py,m10,f0
       pfmul.ss px,m01,f0
       pfmul.ss py,m11,tmp1
       pfmul.ss px,m02,tmp2
       pfadd.ss tmp1,tmp2,f0    // adder 1 = x00+y10
       pfmul.ss py,m12,tmp1
       pfmul.ss pz,m20,tmp2
       pfadd.ss tmp1,tmp2,f0    // adder 1 = x01+y11
       pfmul.ss pz,m21,tmp1
       pfmul.ss pz,m22,tmp2
       pfadd.ss tmp1,tmp2,f0    // adder 1 = x02+y12
       //
       //
       // here we have a full adder and a full multiplier
       // we just drop the numbers out of each and add them
       // leaving 3 results in the adder pipe to store
       //
       //
       m12apm.ss f0,f0,f0     // fill adder unit with adder+mul units
       m12apm.ss f0,f0,f0     //
       m12apm.ss f0,f0,f0     //

       r2ap1.ss m30,f0,f0
       r2ap1.ss m31,f0,f0
       r2ap1.ss m32,f0,f0

       pfadd.ss f0,f0,px
       fst.l px, 0(r16)
       pfadd.ss f0,f0,py
       fst.l py, 4(r16)
       pfadd.ss f0,f0,pz
       bri r1
       fst.l pz, 8(r16)

//}}}  

//{{{  _fn_xform_bound    in 256 ticks == 10 uS on i860-25
        .globl _fn_xform_bound
// void xform_bound ( POINT *dest, POINT *src, MATRIX b )
// a bounding box is 8 points, so we just call xform 8 times

        .align 8
_fn_xform_bound::
        mov r1,r19
        mov r16, r20

        call _fn_cache_opt_mtx
        mov r18,r16

        // call 1
        call _fn_optxform
        mov r20,r16

        // call 2
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 3
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 4
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 5
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 6
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 7
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 8
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17

        bri r19
        nop


//}}}  

//{{{  _fn_xform_boundtroid    in 288 ticks == 10 uS on i860-25
        .globl _fn_xform_boundtroid
// void xform_boundtroid ( POINT *dest, POINT *src, MATRIX b )
// a bounding box plus centroid is 9 points, so we just call xform 9 times

        .align 8
_fn_xform_boundtroid::
        mov r1,r19
        mov r16, r20

        call _fn_cache_opt_mtx
        mov r18,r16

        // call 1
        call _fn_optxform
        mov r20,r16

        // call 2
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 3
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 4
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 5
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 6
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 7
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17
        // call 8
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17

        // call 9
        addu 16,r16,r16
        call _fn_optxform
        addu 16,r17,r17

        bri r19
        nop


//}}}  

//{{{  _fn_concatenate    in 190 ticks == 7.6 uS on i860-25

        .globl _fn_concatenate
// extern void _concatenate ( MATRIX res, MATRIX a, MATRIX b );
// a matrix is 4 points, so we just call xform 8 times

        .align 8
_fn_concatenate::
        mov r1,r19
        mov r16, r20

        mov .C00038, r22

        fxfr tmp5, r21

        call _fn_cache_mtx
        mov r18,r16                 // caches matrix B

        // call 1
        call _fn_xform
        mov r22,r16

        // call 2
        addu 16,r16,r16
        call _fn_xform
        addu 16,r17,r17
        // call 3
        addu 16,r16,r16
        call _fn_xform
        addu 16,r17,r17
        // call 4
        addu 16,r16,r16
        call _fn_xform
        addu 16,r17,r17

        // copy matrix from temporary (r22) to param 1 (r20)

        fld.q  0(r22),f16
        fld.q 16(r22),f20
        fld.q 32(r22),f24
        fld.q 48(r22),f28

        //{{{  double precision stores
        //fst.d   f16, 0(r20)  // store 0
        //fst.d   f18, 8(r20)
        //fst.d   f20, 16(r20)
        //fst.d   f22, 24(r20)
        //fst.d   f24, 32(r20)
        //fst.d   f26, 40(r20)
        //fst.d   f28, 48(r20)
        //fst.d   f30, 56(r20)
        //}}}  
        //{{{  single
        fst.l   f16, 0(r20)  // store 0
        fst.l   f17, 4(r20)  // store 0
        fst.l   f18, 8(r20)
        fst.l   f19, 12(r20)
        fst.l   f20, 16(r20)
        fst.l   f21, 20(r20)
        fst.l   f22, 24(r20)
        fst.l   f23, 28(r20)
        fst.l   f24, 32(r20)
        fst.l   f25, 36(r20)
        fst.l   f26, 40(r20)
        fst.l   f27, 44(r20)
        fst.l   f28, 48(r20)
        fst.l   f29, 52(r20)
        fst.l   f30, 56(r20)
        fst.l   f31, 60(r20)
        //}}}  

        bri r19
        ixfr r21, tmp5

//}}}  

// some rapid hack functions exploiting the 1/sqr(x) opcode

//{{{  quick_renorm
        .globl _quick_renorm
        .align 8


// f8, f9, f10 are normalized, multiplied by f11 and stored to *r16

_quick_renorm::

     fmul.ss f8,  f8,  f19
     fmul.ss f9,  f9,  f20
     fmul.ss f10, f10, f21

     fadd.ss f20, f21, f22
     fadd.ss f19, f22, f23
     frsqr.ss f23, f20
     fmul.ss  f20, f11, f20

     fmul.ss f20, f8,  f8
     fmul.ss f20, f9,  f9
     fmul.ss f20, f10, f10

     fst.l   f8, 0(r16)
     fst.l   f9, 4(r16)
     bri r1
     fst.l   f10, 8(r16)
//}}}  

//{{{  quick_radius
        .globl _quick_radius
        .align 8


// f8, f9, f10 are squared and roughly rooted  -- 18 ticks

_quick_radius::
     fmul.ss f8,  f8,  f19


     fmul.ss f9,  f9,  f20


     fmul.ss f10, f10, f21


     fadd.ss f20, f21, f22


     fadd.ss f19, f22, f23


     frsqr.ss f23, f20
     bri r1
     frcp.ss f20, f8
//}}}  

//{{{  quick_root
        .globl _quick_root
        .align 8


// f8 is roughly square rooted

_quick_root::
     frsqr.ss f8, f20
     bri r1
     frcp.ss f20, f8
//}}}  

//{{{  quick_recip
        .globl _quick_recip
        .align 8


// f8 is roughly 1/f8

_quick_recip::
     bri r1
     frcp.ss f8, f8
//}}}  

#if 0
//{{{  fn_solve ()
        .globl _fn_solve_l
        .align 8
_fn_solve_l::
         fld.l 0(r16), f16
         fld.l 0(r17), f19

         fmul.ss f16, f19, f23
         fld.l 4(r16), f17
         fld.l 4(r17), f20
         fmul.ss f17, f20, f16
         fld.l 8(r16), f18
         fld.l 8(r17), f21
         fmul.ss f18, f21, f17
         fld.l 12(r17), f22
         adds 0, r0, r16
         fadd.ss f23, f16, f19
         fadd.ss f17, f19, f18
         fadd.ss f18, f22, f16

         pfgt.ss f16,f0,f0
         bnc .L55
         adds 1,r0,r16
.L55::
         bri r1
         nop
//}}}  

// old paz structures
//{{{  vertex_copy
//
// vertex_copy
//
//              assumes .double aligned data
//
        .globl _vertex_copy
        .align 8

#define dst r16
#define src r17
#define verts r18
#define itemp r19

// typedef struct s_vert {
//   POINT position;
//   POINT planeEqn;
//   float normcol   [3];
//   struct s_vert *next;
//   float texcoords [2];
// } VERTEX;
//
//   14 words, 7 double register loads
//
_vertex_copy::
          adds   r0, r1, r20
          or    -1,r0,itemp      // decrement by 1
          adds  -1,verts,verts   // correct for bla
          adds  -8,src,src       // correct for autoincrement

          bla itemp,verts,.vcopy_bla
          adds -8,dst,dst       // and again
.vcopy_bla:
          fld.d 8(src)++,f16
          fld.d 8(src)++,f18
          fld.d 8(src)++,f20
          fld.d 8(src)++,f22
          fld.d 8(src)++,f24
          fld.d 8(src)++,f26
          fld.d 8(src)++,f28

          // this should remain cached, its the render_strip, hit
          // hard every strip
          fst.d f16,8(dst)++
          fst.d f18,8(dst)++
          fst.d f20,8(dst)++
          fst.d f22,8(dst)++
          fst.d f24,8(dst)++
          fst.l f26,8(dst)++   // dont copy next field !
          bla itemp,verts,.vcopy_bla
          fst.d f28,8(dst)++

          bri r1
          nop

#undef dst
#undef src
#undef verts
#undef itemp

//}}}  
//{{{  pmesh_tri_copy
//
// pmesh_tri_copy
//
//
//
        .globl _pmesh_tri_copy
        .align 8

#define dst r16
#define src r17
#define verts r18
#define delta r19
#define itemp r20

// typedef struct s_vert {
//   POINT position;
//   POINT planeEqn;
//   float normcol   [3];
//   struct s_vert *next;
//   float texcoords [2];
// } VERTEX;
//
//   do 3 triangle pointers, zero W, do plane equation
//
_pmesh_tri_copy::
          or    -1,r0,itemp      // decrement by 1
          adds  -1,verts,verts   // correct for bla

          bla itemp,verts,.tcopy_bla
          nop
.tcopy_bla:
          ld.l  0(src), r29
          ld.l  4(src), r30
          adds  r29, delta, r29
          ld.l  8(src), r31
          adds  r30, delta, r30
          fld.d 16(src), f16
          adds  r31, delta, r31
          fld.d 24(src), f18

          st.l  r29, 0(dst)
          st.l  r30, 4(dst)
          st.l  r31, 8(dst)
          st.l  r0,  12(dst)

          fst.d f16, 16(dst)
          fst.d f18, 24(dst)

          adds 56, src, src
          bla itemp,verts,.tcopy_bla
          adds 56, dst, dst

          bri r1
          nop



#undef dst
#undef src
#undef verts
#undef delta
#undef itemp

//}}}  
//{{{  pmesh_vertex_copy
//
// pmesh_vertex_copy
//
//              assumes .double aligned data
//
        .globl _pmesh_vertex_copy
        .align 8

#define dst r16
#define src r17
#define verts r18
#define itemp r19

// typedef struct s_vert {
//   POINT position;
//   POINT planeEqn;
//   float normcol   [3];
//   struct s_vert *next;
//   float texcoords [2];
// } VERTEX;
//
//   we only need to copy position, normcol and texcoords
//
_pmesh_vertex_copy::
          or    -1,r0,itemp      // decrement by 1
          adds  -1,verts,verts   // correct for bla
          adds -8, src, src
          bla itemp,verts,.pvcopy_bla
          adds -8, dst, dst
.pvcopy_bla:
          fld.d  8(src),f16
          fld.d  16(src),f18  // position
          fld.d  40(src),f20
          fld.d  48(src),f22  // normcol/next
          fld.d  56(src)++,f24

          // this should remain cached, its the render_strip, hit
          // hard every strip
          fst.d f16, 8(dst)
          fst.d f18,16(dst)
          fst.d f20,40(dst)
          fst.d f22,48(dst)  // dont bash the next ptr
          bla itemp,verts,.pvcopy_bla
          fst.d f24,56(dst)++

          bri r1
          nop

#undef dst
#undef src
#undef bytes

//}}}  

//{{{  _fn_solve
        .globl _fn_solve
        .align 8
_fn_solve::
         fld.l 0(r16), f16
         fld.l 4(r16), f17
         fld.l 0(r17), f20
         fld.l 4(r17), f21
         // we are computing
         //
         //  r16( 0)*r17( 0)  +
         //  r16( 4)*r17( 4)  +
         //  r16( 8)*r17( 8)  +
         //  r16(12) > 0
         //
         //  18 ticks raw, now done in 11
         //
         //  in fact we can compute
         //  ax + bx + cz > d, if we store -d rather than d into
         //  plane equation
         //
         d.pfmul.ss f16, f20, f0
           fld.l 8(r16), f18
         d.pfmul.ss f17, f21, f0
           fld.l 8(r17), f22
         pfmul.ss f18, f22, f0
           fld.l 12(r16), f19
         iat1p2.ss f0, f0, f0
           adds 0, r0, r16
         m12tpm.ss f0, f0, f0   // push px*ptx + py*pty into adder
         iat1p2.ss f0, f0, f0   // push pz*ptz into t
         pfadd.ss  f0, f0, f0   // push partial into last-stage adder
         m12tpa.ss f0, f0, f0   // and push dot-product into adder
         pfadd.ss  f0, f0, f0   // stage 2
         pfadd.ss  f0, f0, f0   // stage 3
         pfadd.ss  f0, f0, f16  // stage 3

         pfgt.ss f16,f19,f0     // will run some 50% faster
         bnc .Ld55
         adds 1,r0,r16
.Ld55::
         bri r1
         nop
//}}}  
//{{{  _fn_solve
        .globl _fn_solve
        .align 8
_fn_solve::
         fld.d 0(r16), f16
         fld.d 0(r17), f18

         fmul.ss f16, f18, f23
         fld.d 8(r17), f20
         fld.l 8(r16), f22
         fmul.ss f17, f19, f16
         fmul.ss f22, f20, f17
         adds 0, r0, r16
         fadd.ss f23, f16, f19
         fadd.ss f17, f19, f18
         fadd.ss f22, f18, f16

         pfgt.ss f16,f0,f0
         bnc .Ld55
         adds 1,r0,r16
.Ld55::
         bri r1
         nop
//}}}  
//{{{  _fn_distance_strip
        .globl _fn_distance_strip
        .align 8

//
// fn_distance_strip ( POINT inveye, VERTEX *v1, int n_tris, float scaleFac )
//
// this puts the point into the plane equation and saves the answer into
// vert->position[3]
//

#define inveye   r16
#define vertex   r17
#define n_tris   r18
#define minus_1  r20
#define scaleFac f8

_fn_distance_strip::
         // exit if loop count == 0
         bte r0, n_tris, .exit_distance_strip

         // load up inverse eye position (constant for strip)
         fld.l  0(inveye), f16
         fld.l  4(inveye), f17
         fld.l  8(inveye), f18

         //
         // we are computing
         //
         //  r16( 0)*r17( 0)  +
         //  r16( 4)*r17( 4)  +
         //  r16( 8)*r17( 8)  - r16(12)
         //
         //  ax + bx + cz > d, but we MUST store -d rather than d into
         //  plane equation
         //
         adds -1, n_tris, n_tris
         adds -1, r0, minus_1

         bla minus_1, n_tris, .distance_point_db
         fld.l 16(vertex), f20

.distance_point::
         fld.l 16(vertex), f20
.distance_point_db::
         fld.l 20(vertex), f21
         fld.l 24(vertex), f22
         fld.l 28(vertex), f19

         pfmul.ss f16, f20, f0
         pfmul.ss f17, f21, f0
         pfmul.ss f18, f22, f0
         iat1p2.ss f0, f0, f0
         m12tpm.ss f0, f0, f0   // push px*ptx + py*pty into adder
         iat1p2.ss f0, f0, f0   // push pz*ptz into t
         pfadd.ss  f0, f0, f0   // push partial into last-stage adder
         m12tpa.ss f0, f0, f0   // and push dot-product into adder
         pfadd.ss  f0, f0, f0   // stage 2
         pfadd.ss  f0, f0, f0   // stage 3
         pfadd.ss  f0, f0, f20  // stage 3

         fsub.ss   f20, f19, f21
         fmul.ss   f21, f21, f20
         frcp.ss   f20, f21
         frsqr.ss  f21, f20
         fmul.ss   f20, scaleFac, f21
         st.l  f21, 12(vertex)
         bla minus_1, n_tris, .distance_point
         adds  56, vertex, vertex

.exit_distance_strip::
         bri r1
         nop
//}}}  
//{{{  _fn_view_distance
        .globl _fn_view_distance
        .align 8

#define inveye  r16
#define vertex  r17

_fn_view_distance::
         // load up inverse eye position (constant for strip)
         fld.l  0(inveye), f16
         fld.l  4(inveye), f17
         fld.l  8(inveye), f18

         fld.l 16(vertex), f20
         fld.l 20(vertex), f21
         fld.l 24(vertex), f22
         fld.l 28(vertex), f19

         pfmul.ss f16, f20, f0
         pfmul.ss f17, f21, f0
         pfmul.ss f18, f22, f0
         iat1p2.ss f0, f0, f0
         m12tpm.ss f0, f0, f0   // push px*ptx + py*pty into adder
         iat1p2.ss f0, f0, f0   // push pz*ptz into t
         pfadd.ss  f0, f0, f0   // push partial into last-stage adder
         m12tpa.ss f0, f0, f0   // and push dot-product into adder
         pfadd.ss  f0, f0, f0   // stage 2
         pfadd.ss  f0, f0, f0   // stage 3
         pfadd.ss  f0, f0, f20  // stage 3

         fsub.ss   f20, f19, f20
         fmul.ss   f20, f20, f19
         frcp.ss   f20, f19
         bri r1
         frsqr.ss  f20, f8
//}}}  
//{{{  _fn_xform_strip    in 32 ticks per point == 790 k xforms/sec on i860-25
        .globl _fn_xform_strip
// extern float fn_xform_strip ( VERTEX *head, MATRIX m, int n );

        .align 8
_fn_xform_strip::
        subs r0, r18, r0
        bnc .getout

        mov r1,r19

        mov r16, r20
        call _fn_cache_opt_mtx
        mov r17,r16

        adds -1,r18,r18  // prepare n for auto decrement
        adds -1,r0,r21   // using -1 as decrement
        bla r21,r18,.dloop
.dloop:
        fld.d 0(r20),px

        pfmul.ss px,m00,f0
        pfmul.ss py,m10,f0
        fld.l 8(r20),pz
        pfmul.ss px,m01,f0
        pfmul.ss py,m11,tmp1
        pfmul.ss px,m02,tmp2
        pfadd.ss tmp1,tmp2,f0    // adder 1 = x00+y10
        pfmul.ss py,m12,tmp1
        pfmul.ss pz,m20,tmp2
        pfadd.ss tmp1,tmp2,f0    // adder 1 = x01+y11
        pfmul.ss pz,m21,tmp1
        pfmul.ss pz,m22,tmp2
        pfadd.ss tmp1,tmp2,f0    // adder 1 = x02+y12
        m12apm.ss f0,f0,f0     // fill adder unit with adder+mul units
        m12apm.ss f0,f0,f0     //
        m12apm.ss f0,f0,f0     //

        r2ap1.ss m30,f0,f0
        r2ap1.ss m31,f0,f0
        r2ap1.ss m32,f0,f0

        pfadd.ss f0,f0,px
        pfadd.ss f0,f0,py
        pfadd.ss f0,f0,pz
        fst.d px, 0(r20)
        adds 56, r20, r20

        bla r21,r18,.dloop
        fst.l pz, -48(r20)

        bri r19
        nop
.getout:
        bri r1
        nop
//}}}  
//{{{  _fn_solve_strip
        .globl _fn_solve_strip
        .align 8

#define texScaleFac f8

//
// fn_solve_strip ( POINT inveye, VERTEX *v1, int n_tris )
//
// this puts the point into the plane equation and saves the answer into
// vert->position[3]
//

#define inveye   r16
#define vertex   r17
#define n_tris   r18
#define twosided r19
#define one      r20
#define minus_1  r21


_fn_solve_strip::
         // exit if loop count == 0
         bte r0, n_tris, .exit_solve_strip

         // load up inverse eye position (constant for strip)
         fld.l  0(inveye), f16
         fld.l  4(inveye), f17
         fld.l  8(inveye), f18

         //
         // we are computing
         //
         //  r16( 0)*r17( 0)  +
         //  r16( 4)*r17( 4)  +
         //  r16( 8)*r17( 8)  > r16(12)
         //
         //  ax + bx + cz > d, but we MUST store -d rather than d into
         //  plane equation
         //
         adds -1, n_tris, n_tris
         adds -1, r0, minus_1

         bla minus_1, n_tris, .solve_point
         or    1, r0,  one

.solve_point::
         fld.l 16(vertex), f20
         fld.l 20(vertex), f21
         fld.l 24(vertex), f22
         fld.l 28(vertex), f19

         pfmul.ss f16, f20, f0
         pfmul.ss f17, f21, f0
         pfmul.ss f18, f22, f0
         iat1p2.ss f0, f0, f0
         m12tpm.ss f0, f0, f0   // push px*ptx + py*pty into adder
         iat1p2.ss f0, f0, f0   // push pz*ptz into t
         pfadd.ss  f0, f0, f0   // push partial into last-stage adder
         m12tpa.ss f0, f0, f0   // and push dot-product into adder
         pfadd.ss  f0, f0, f0   // stage 2
         pfadd.ss  f0, f0, f0   // stage 3
         pfadd.ss  f0, f0, f20  // stage 3

         pfgt.ss f20,f19,f0

         bnc .solution_zero

.solution_one::
         fsub.ss  f20, f19, f31
         fmul.ss  f31, f31, f20
         frsqr.ss f20, f21
         fmul.ss  f21, texScaleFac, f20
         fxfr f20, r31
         or 1, r31, r31
         st.l  r31, 12(vertex)
         bla minus_1, n_tris, .solve_point
         adds  56, vertex, vertex

.exit_solve_strip::
         bri r1
         nop

.solution_zero::
         or r0, twosided, r0
         bnc .solution_zeroish

.solution_straight_zero::
         st.l  r0, 12(vertex)
         bla minus_1, n_tris, .solve_point
         adds  56, vertex, vertex

         bri r1
         nop

.solution_zeroish::
         fsub.ss  f20, f19, f31
         fmul.ss  f31, f31, f20
         frsqr.ss f20, f21
         fmul.ss  f21, texScaleFac, f20
         fxfr f20, r31
         andh 0xffff, r31, r31
         st.l  r31, 12(vertex)
         // st.l  r0, 12(vertex)
         bla minus_1, n_tris, .solve_point
         adds  56, vertex, vertex

         bri r1
         nop

//}}}  
//{{{  _fn_solve_pmesh
        .globl _fn_solve_pmesh
        .align 8

//
// fn_solve_pmesh ( POINT inveye, VERTEX *v1, int n_tris )
//
// this puts the point into the plane equation and saves the answer into
// vert->position[3], and also flags each vertex (in position[0],[1],[2])
// as requiring transformation
//
// note that we cant just blindly drop the result into the vertex, as
// a shared vertex is likely to have bothe +ve and -ve solutions, so
// we need 2 copies of the loop, one which saves the result and one
// which doest, and we have to bla to the correct one dependent on the
// result
//
// by coding this up in dual-instruction mode, the stores to the triangles
// come (virtually) for free - now we just need an xflghtpr with
// conditional behaviour
//
//

#define inveye      r16
#define vertex      r17
#define n_tris      r18
#define twosided    r19

#define one         r20
#define minus_1     r21
#define prev_vertex r22
#define v0          r23
#define v1          r24
#define v2          r25

_fn_solve_pmesh::
         // exit if loop count == 0
         bte r0, n_tris, .exit_solve_strip

         // load up inverse eye position (constant for strip)
         fld.l  0(inveye), f16
         fld.l  4(inveye), f17
         fld.l  8(inveye), f18

         adds r0, vertex, prev_vertex

         //
         // we are computing
         //
         //  r16( 0)*r17( 0)  +
         //  r16( 4)*r17( 4)  +
         //  r16( 8)*r17( 8)  > r16(12)
         //
         //  ax + bx + cz > d, but we MUST store -d rather than d into
         //  plane equation
         //
         adds -1, n_tris, n_tris
         adds -1, r0, minus_1

         bla minus_1, n_tris, .pmesh_solve_point_dont_write
         or    1, r0,  one

         .align 8
.pmesh_solve_point_do_write::
         d.pfmul.ss f0, f0, f0
           fld.l 16(vertex), f20
         d.pfmul.ss f0, f0, f0
           fld.l 20(vertex), f21
         d.pfmul.ss f0, f0, f0
           fld.l 28(vertex), f19
         d.pfmul.ss f16, f20, f0
           fld.l 24(vertex), f22
         d.pfmul.ss f17, f21, f0
           ld.l  0(prev_vertex), v0
         d.pfmul.ss f18, f22, f0
           nop
         d.iat1p2.ss f0, f0, f0
           nop
         d.m12tpm.ss f0, f0, f0   // push px*ptx + py*pty into adder
           ld.l  4(prev_vertex), v1
         d.iat1p2.ss f0, f0, f0   // push pz*ptz into t
           nop
         d.pfadd.ss  f0, f0, f0   // push partial into last-stage adder
           nop
         d.m12tpa.ss f0, f0, f0   // and push dot-product into adder
           ld.l  8(prev_vertex), v2
         d.pfadd.ss  f0, f0, f0   // stage 2
           st.l one, 12(v0)
         d.pfadd.ss  f0, f0, f0   // stage 3
           st.l one, 12(v1)
         pfadd.ss  f0, f0, f20    // stage 3
           st.l one, 12(v2)
         pfgt.ss f20,f19,f0
           adds r0, vertex, prev_vertex
         bnc .pmesh_solution_zero
         br  .pmesh_solution_one
         nop // st.l  one, 12(vertex)

         .align 8
.pmesh_solve_point_dont_write::
         d.pfmul.ss f0, f0, f0
           fld.l 16(vertex), f20
         d.pfmul.ss f0, f0, f0
           fld.l 20(vertex), f21
         d.pfmul.ss f0, f0, f0
           fld.l 28(vertex), f19
         d.pfmul.ss f16, f20, f0
           fld.l 24(vertex), f22
         d.pfmul.ss f17, f21, f0
           nop
         d.pfmul.ss f18, f22, f0
           nop
         d.iat1p2.ss f0, f0, f0
           nop
         d.m12tpm.ss f0, f0, f0   // push px*ptx + py*pty into adder
           nop
         d.iat1p2.ss f0, f0, f0   // push pz*ptz into t
           nop
         d.pfadd.ss  f0, f0, f0   // push partial into last-stage adder
           nop
         d.m12tpa.ss f0, f0, f0   // and push dot-product into adder
           nop
         d.pfadd.ss  f0, f0, f0   // stage 2
           nop
         d.pfadd.ss  f0, f0, f0   // stage 3
           nop
         pfadd.ss  f0, f0, f20    // stage 3
           adds r0, vertex, prev_vertex
         pfgt.ss f20,f19,f0
           nop
         bnc .pmesh_solution_zero

.pmesh_solution_one::
         // do full distance solution
         // which involves computing square of distance
         // to plane, rooting it, then clearing bottom bit
         //fsub.ss  f20, f19, f31
         //fmul.ss  f31, f31, f21
         //frsqr.ss f21, f20
         //fmul.ss  f20, texScaleFac, f20
         //fxfr f20, r31
         //or 1, r31, r31
         or 1, r0, r31
         st.l  r31, 12(vertex)
         bla minus_1, n_tris, .pmesh_solve_point_do_write
         adds  56, vertex, vertex

.exit_solve_pmesh::

         // wind down result of last triangle

         ld.l  0(prev_vertex), v0
         ld.l  4(prev_vertex), v1
         ld.l  8(prev_vertex), v2
         st.l one, 12(v0)
         st.l one, 12(v1)
         bri r1
         st.l one, 12(v2)

.pmesh_solution_zero::
         // if twosided, do solution
         or r0, twosided, r0
         bc .pmesh_straight_zero
         // so, twosided, do full distance solution
         // which involves computing square of distance
         // to plane, rooting it, then clearing bottom bit
         //fsub.ss  f20, f19, f31
         //fmul.ss  f31, f31, f21
         //frsqr.ss f21, f20
         //fmul.ss  f20, texScaleFac, f20
         //fxfr f20, r31
         //andh 0xffff, r31, r31
         //st.l  r31, 12(vertex)
         st.l  r0, 12(vertex)
         bla minus_1, n_tris, .pmesh_solve_point_dont_write
         adds  56, vertex, vertex

         bri r1
         nop



.pmesh_straight_zero::
         st.l  r0, 12(vertex)
         bla minus_1, n_tris, .pmesh_solve_point_dont_write
         adds  56, vertex, vertex

         bri r1
         nop
//}}}  
#endif




//{{{  copy_spoint
        .globl  _copy_spoint
        .align  8
//
// hand-coded this as i was disgusted with the compilers output
//

_copy_spoint:
        adds -1, r0, r18
        adds 6, r0, r19
        adds 4, r0, r20
        adds -4, r16, r16
        bla r18, r19,.B1264
        adds -4, r17, r17
.B1264:
        fld.l r20(r16)++, f16
        bla r18, r19, .B1264
        fst.l f16, r20(r17)++
        
        bri r1
        nop
//}}}  

//{{{  smintersect
        .globl  _smintersect
        .align  8

//
// this is slightly hand-tweaked compiler output
// it looks like some 89 cycles, and should be tweakable down to about 45
//
_smintersect:
// lineno: 234
        shl 2, r19, r29
        fld.l r17(r29), f16
        fld.l r18(r29), f17
        orh ha%.C00037, r0, r31
        fld.l l%.C00037(r31), f21
        fsub.ss f17, f16, f18


        frcp.ss f18, f19
        fmul.ss f18, f19, f20
        fld.l r0(r17), f29
        fld.l r0(r18), f30
        
        
        fsub.ss f21, f20, f22
        
        
        fmul.ss f19, f22, f23
        
        
        fmul.ss f18, f23, f24
        
        
        fsub.ss f21, f24, f25
        
        
        fmul.ss f25, f23, f26
        
        
        fsub.ss f8, f16, f27
        
        
        fmul.ss f27, f26, f28
        
        
        fsub.ss f30, f29, f31
        
        
        fmul.ss f31, f28, f9
        fld.l 4(r17), f11
        fld.l 4(r18), f12
        fadd.ss f29, f9, f10
        
        
        fsub.ss f12, f11, f13
        fst.l f10, r0(r16)
        
        fmul.ss f28, f13, f14
        fld.l 8(r17), f17
        fld.l 8(r18), f20
        fadd.ss f11, f14, f15
        

        fsub.ss f20, f17, f22
        fst.l f15, 4(r16)
        
        fmul.ss f28, f22, f19
        fld.l 16(r17), f21
        fld.l 16(r18), f23
        fadd.ss f17, f19, f24
        
        
        fsub.ss f23, f21, f25
        fst.l f24, 8(r16)
        
        fmul.ss f28, f25, f18
        fld.l 20(r17), f26
        fld.l 20(r18), f27
        fadd.ss f21, f18, f16
        

        fsub.ss f27, f26, f30
        fst.l f16, 16(r16)
        
        fmul.ss f28, f30, f31
        fld.l 24(r18), f10
        fld.l 24(r17), f29
        fadd.ss f26, f31, f9
        
        
        fsub.ss f10, f29, f12
        fst.l f9, 20(r16)
        
        fmul.ss f28, f12, f13
        
        fst.l f8, r29(r16)
        fadd.ss f29, f13, f14
        
        bri r1 
        fst.l f14, 24(r16)
//}}}  

//{{{  _dnc_wait_count
        .globl _dnc_Wait_count
        .align 8

//      while (*r16 == 0) spin(r17);

_dnc_Wait_count::
        or r0, r0, r20
dnc_Wait_count1::
        adds 1, r20, r20
        st.l r20, 4(r16)
        ld.l r0(r16), r18
        btne r0,r18,.wait_loop
        adds 1,r0,r18
        bri r1
        st.l r18,0(r16)

.wait_loop::
       or r17,r0,r19
       adds -1,r0,r18
       bla r18,r19,.wait_spin
       nop
.wait_spin::
       bla r18,r19,.wait_spin
       nop
       br dnc_Wait_count1
       nop

//}}}  

//{{{  _bla
        .globl _bla
        .align 8

        // simply loops r16 times, taking 2 x r16 cycles
_bla::
        adds -1,r0,r17
        bla r17,r16,bla_bla
        nop
bla_bla::
        bla r17,r16,bla_bla
        nop

        bri r1
        nop
//}}}  

//{{{  _xform_and_project_fn:
        .globl _xform_and_project_fn
        .align 8

_xform_and_project_fn:
.a18 = 0
.f18 = 96
        orh h%.STACK+.f18-16, r0, r28
        or l%.STACK+.f18-16, r28, r28
        fst.d f2, -72(r28)
        fst.d f4, -64(r28)
        fst.d f6, -56(r28)
        st.l r4, -48(r28)
                                                                            
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
                                                                                
        
        
        
        
        
        
// lineno: 0
        orh ha%.C00037, r0, r31
        fld.l l%.C00037(r31), f15
        adds -1, r0, r19
// lineno: 1281
        orh ha%.C00036, r0, r31
        fld.l l%.C00036(r31), f16
        fld.l 172(r16), f17
        fld.l 144(r16), f19
        fld.l 176(r16), f22
        fadd.ss f17, f16, f18
        orh ha%_sub_pixel_correct, r0, r31
        fld.l l%_sub_pixel_correct(r31), f2
        fmul.ss f19, f18, f20
        fld.l 152(r16), f24
        fld.l 164(r16), f26
        fadd.ss f2, f20, f21
        fld.l 128(r16), f27
        fld.l 8(r17), f31
        fst.l f21, -40(r28)
        fadd.ss f22, f16, f23
        orh ha%_Czscale, r0, r31
        fld.l l%_Czscale(r31), f29
        fmul.ss f24, f23, f25
        fld.l 12(r17), f17
        fld.l 24(r17), f18
        fadd.ss f2, f25, f7
        fld.l 28(r17), f20
        fld.l 40(r17), f21
        fmul.ss f27, f26, f28
        fld.l 44(r17), f16
        fld.l 56(r17), f22
        fmul.ss f29, f28, f5
        fld.l 60(r17), f23
        fld.l 16(r17), f11
        fmul.ss f27, f19, f30
        fld.l 32(r17), f12
        fld.l 48(r17), f13
        fst.l f30, -36(r28)
        fmul.ss f27, f24, f6
        fld.l 64(r17), f14
        ld.l 4(r18), r4
        fst.l f31, -4(r28)
        fst.l f17, -8(r28)
        fst.l f18, -12(r28)
        fst.l f20, -16(r28)
        fst.l f21, -20(r28)
        fst.l f16, -24(r28)
        fst.l f22, -28(r28)
        fst.l f23, -32(r28)
        addu 8, r18, r21
        subs 0, r4, r0
        
        bnc .B1209
        adds -1, r4, r20
        bla r19, r20,.B1878
        pfmul.dd f0, f0, f0
// lineno: 1307
.B1878: //.M0014
.align 8
        d.pfadd.dd  f0,  f0,  f0
                nop
.align 8
.PD0.B1878105:
        d.fnop
                ld.l 76(r21), r18
        d.fnop
                fld.l r0(r21), f16
.DB.B18781878:  
        d.fnop
                fld.l 4(r21), f9
        d.fnop
                fld.l 8(r21), f20
        d.pfmul.ss f16, f11, f0
                and r18, r18, r0
        d.pfmul.ss f9, f12, f0
                fld.l -4(r28), f31
        d.pfmul.ss f20, f13, f0
                bc  .not_touched
        d.pfmul.ss f31, f16, f17
                nop
        d.mi2p1.ss f17, f0, f18
                fld.l -12(r28), f31
        d.mm12msm.ss f0, f0, f21
                nop
        d.mm12msm.ss f0, f0, f18
                nop
        d.pfadd.ss f21, f19, f19
                nop
        d.mm12msm.ss f31, f9, f0
                fld.l -20(r28), f21
        d.mm12msm.ss f0, f0, f0
                nop
        d.ia1p2.ss f14, f22, f22
                nop
        d.mm12msm.ss f0, f0, f17
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f0, f0, f23
                nop
        d.frcp.ss f23, f24
                nop
        d.pfmul.ss f23, f24, f0
                nop
        d.ia1p2.ss f18, f17, f0
                nop
        d.mm12msm.ss f21, f20, f0
                fld.l -28(r28), f17
        d.mi2s1.ss f15, f0, f25
                fld.l -36(r28), f18
        d.ia1p2.ss f0, f0, f19
                nop
        d.mi2p1.ss f19, f0, f31
                nop
        d.m12tpa.ss f24, f26, f26
                fld.l -40(r28), f31
        d.mm12msm.ss f0, f0, f0
                fld.l -8(r28), f24
        d.ia1p2.ss f17, f22, f22
                nop
        d.mm12msm.ss f23, f27, f27
                fld.l -16(r28), f17
        d.mm12msm.ss f16, f24, f0
                nop
        d.m12tpa.ss f18, f4, f4
                nop
        d.mi2s1.ss f15, f0, f28
                fld.l -24(r28), f18
        d.mm12msm.ss f0, f0, f22
                nop
        d.mm12msm.ss f9, f17, f21
                nop
        d.m12tpa.ss f20, f18, f29
                nop
        d.pfmul.ss f27, f29, f0
                fld.l -32(r28), f18
        d.mi2p1.ss f22, f0, f24
                nop
        d.mm12msm.ss f0, f0, f28
                nop
        d.mm12msm.ss f21, f30, f30
                nop
        d.ia1p2.ss f28, f16, f16
                nop
        d.mm12msm.ss f5, f30, f0
                nop
        d.mi2p1.ss f31, f0, f25
                nop
        d.ia1p2.ss f18, f17, f17
                nop
        d.mm12msm.ss f0, f0, f24
                fst.l f24, 56(r21)
        d.pfsub.ss f19, f2, f19
                nop
        d.m12tpa.ss f6, f3, f3
                nop
        d.mm12msm.ss f0, f0, f0
                nop
        d.ia1p2.ss f0, f0, f26
                fst.l f26, 48(r21)
        d.pfmul.ss f30, f20, f20
                nop
        d.pfmul.ss f0, f0, f0
                nop
        d.pfmul.ss f0, f0, f0
                nop
        d.mi2p1.ss f7, f0, f29
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfsub.ss f27, f2, f27
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f0, f0, f0
                nop
        d.pfadd.ss f0, f0, f23
                fst.l f23, 52(r21)
        d.fiadd.ss f30, f0, f8
                nop
.not_touched:
        d.fnop
                ld.l 44(r21), r21
        d.fnop
                bla r19, r20, .PD0.B1878105
        d.fnop
                nop
.align 8
        fnop
                nop
        fnop
                nop
// lineno: 0
// lineno: 0
.B1209: //.B0085
// lineno: 1321
        
        
        
        
        fld.d -72(r28), f2
        fld.d -64(r28), f4
        fld.d -56(r28), f6
        ld.l -48(r28), r4
        bri r1
        nop
        .align  8
//}}}  

//{{{  _solve_fn:
        .globl _solve_fn
        .align 8

_solve_fn:
.a16 = 0
.f16 = 32
        orh h%.STACK+.f16-16, r0, r28
        or l%.STACK+.f16-16, r28, r28
        st.l r4, -8(r28)
        
// lineno: 0
        adds 1, r0, r19
// lineno: 1403
        fld.d r0(r17), f8
        fld.d 8(r17),  f10
        addu 8, r16, r4
        bte 0x0000, r4, .sB1176

// lineno: 1410
.sB1819: //.M0012
        fld.d 32(r4), f16
.sDB.B18191819:
        fld.d 40(r4), f18
        // plane eqn now in f16 f17 f18 f19,
        // view in          f8  f9  f10 f11

        pfmul.ss f8,  f16, f0
        pfmul.ss f9,  f17, f0
        pfmul.ss f10, f18, f0
        pfmul.ss f11, f19, f16  // f16=nx*vx
        i2p1.ss  f16, f0,  f0   // adder 1=nx.vx+ny.vy
        i2ap1.ss f0,  f0, f0    // t=nz.vz
        i2pt.ss  f0,  f0, f0    // adder 1=nz.vz+nw.vw
        pfadd.ss f0,  f0, f16   // f16 = first 2
        pfadd.ss f0,  f0, f0    // click adder
        i2ap1.ss f16, f0, f0    // adder1=total
        pfadd.ss f0,  f0, f0    // click adder
        pfadd.ss f0,  f0, f0    // click adder
        pfadd.ss f0,  f0, f26   // got it

        pfle.ss f26, f0, f0
        ld.l 8(r4), r29
        
        bnc .sB1178
        st.l r19, 60(r4)
        adds 3, r0, r18
        addu 16, r4, r24
        st.l r19, 76(r29)
        addu 4, r4, r25
        ld.l 12(r4), r30
        
        st.l r19, 76(r30)
        
        ld.l 16(r4), r22
        
        st.l r19, 76(r22)
        
        ld.l 4(r4), r23
        
        subs r18, r23, r0
        
        bnc .sB1181
        mov r24, r20
        mov r25, r21
// lineno: 1420
.sB1818: //.M0011
        ld.l 4(r20), r29
.sDB.B18181818:
        addu 4, r20, r20
        st.l r19, 76(r29)
        adds r19, r18, r18
        ld.l r0(r21), r30
        
        subs r18, r30, r0
        
        bc.t .sDB.B18181818
        ld.l 4(r20), r29
// lineno: 0
// lineno: 1421
.sB1181: //.B0100
        br .sDB.B11831183
        ld.l r0(r4), r4
// lineno: 1425
.sB1178: //.B0098
        st.l r0, 60(r4)
.sDB.B11781178:
// lineno: 1427
.sB1183: //.B0101
        ld.l r0(r4), r4
.sDB.B11831183:
        
        xor 0x0000, r4, r0
        bnc.t .sDB.B18191819
        fld.d 32(r4), f16
// lineno: 0
// lineno: 0
.sB1176: //.B0097
// lineno: 1428
        
        bri r1
        ld.l -8(r28), r4
//}}}  

#if 0
//{{{  _dnc_wait_count
        .globl _dnc_Wait_count
        .align 32

//      while (*r16 == 0) spin(r17);

_dnc_Wait_count::
        lock
        ld.l r0(r16), r18
        btne r0,r18,.wait_loop
        adds 1,r0,r18
        unlock
        st.l r18,0(r16)
        bri r1
        st.l r0,4(r16)

.wait_loop::
       unlock
       st.l r0,4(r16)
       st.l r0,4(r16)
       or r17,r0,r19
       adds -1,r0,r18
       bla r18,r19,.wait_spin
       nop
.wait_spin::
       bla r18,r19,.wait_spin
       nop
       br _dnc_Wait_count
       nop

//}}}  
//{{{  _wait_locked_nonzero
        .globl _wait_locked_nonzero
        .align 32

//      while (*r16 != 0) spin(r17);

_wait_locked_nonzero::
        bte  0x0, r16, .wait_locked_exit
        lock
        ld.l r0(r16), r18
        bte 0x0, r18, .wait_locked_loop

        unlock
        st.l r0, 4(r16)
        st.l r0, 4(r16)
.wait_locked_exit::
        bri r1
        nop

.wait_locked_loop::
        unlock
        st.l r0, 4(r16)
        st.l r0, 4(r16)

        or r17,r0,r19
        adds -1,r0,r18
        bla r18,r19,.wait_locked_spin
        nop
.wait_locked_spin::
        bla r18,r19,.wait_locked_spin
        nop
        br _wait_locked_nonzero
        nop

//}}}  
#endif

//{{{  _wait_locked_nonzero
        .globl _wait_locked_nonzero
        .align 8

//      while (*r16 != 0) spin(r17);
_wait_locked_nonzero::
        or r0, r0, r20
wait_locked_nonzero1::
        adds 1, r20, r20
        st.l r20, 4(r16)
        bte  0x0, r16, .wait_locked_exit
        ld.l r0(r16), r18
        bte 0x0, r18, .wait_locked_loop
.wait_locked_exit::
        bri r1
        nop

.wait_locked_loop::
        or r17,r0,r19
        adds -1,r0,r18
        bla r18,r19,.wait_locked_spin
        nop
.wait_locked_spin::
        bla r18,r19,.wait_locked_spin
        nop
        br wait_locked_nonzero1
        nop

//}}}  

//{{{  _i860_locked_read
        .globl _i860_locked_read
        .align 8

_i860_locked_read::
        lock
        ld.l r0(r16), r17
        unlock
        st.l r0, 4(r16)
        bri r1
        mov r17, r16

//}}}  

//{{{  _manual_flush

        .globl _manual_flush
        .align 8

#define Rr r17
#define Rs r18
#define Rt r19
#define Ru r20
#define Rv r21
#define Rw r22
#define Rx r23
#define Ry r24
#define DIRB_rb 0xc00
#define DIRB_rc 0x300

_manual_flush::
    mov r1, Rr
    ld.c dirbase, Rv
    andnot 0x0f00, Rv, Ru
    adds -1, r0, Rx
    adds -32, r16, Rt

// flush pass 1
    or 0x800, Ru, Rs
    call D_FLUSH
    st.c Rs, dirbase
// flush pass 2
    or 0x900, Ru, Rs
    call D_FLUSH
    st.c Rs, dirbase
// am i an XP?
   ld.c epsr, Rs
   shr 19, Rs, Rs
   and 0x07, Rs, Rs
   bc RESTORE_DIRBASE
// flush pass 3
    or 0xa00, Ru, Rs
    call D_FLUSH
    st.c Rs, dirbase
// flush pass 4
    or 0xb00, Ru, Rs
    call D_FLUSH
    st.c Rs, dirbase
RESTORE_DIRBASE::
    st.c Rv, dirbase
    nop
    nop
    nop
    nop
    nop
    nop
    bri Rr
    nop

D_FLUSH::
    mov 127, Ry
    bla Rx,Ry,D_FLUSH_LOOP
    mov Rt, Rw
D_FLUSH_LOOP::
    bla Rx,Ry,D_FLUSH_LOOP
    flush 32(Rw)++

    bri r1
    nop

//}}}  

//{{{  some data
        .data
        .align  8

.C00036:        // (16)
        .long   0x3f800000      // 1.00000000E+00

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

        .align  16
.C00038:
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0
        .long   0x0

.C00066:        // (64)
        .long   0x3f800000      // 1.00000000E+00

.C00067:        // (64)
        .long   0xbf800000      // -1.00000000E+00

        .lcomm  .STACK,96
        .lcomm  .BSS,32

//}}}