home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / basic / compiler / ubasic / ubmpqs32 / mpqshd2p.asm < prev    next >
Assembly Source File  |  1990-08-06  |  12KB  |  821 lines
  1. ;MPQSHD2P.ASM 3.2
  2. ;    MACHINE LANGUAGE SUBROUTINE
  3. ;    FOR MULTIPLE POLYNOMIAL QUADRATIC SIEVE
  4. ;    PROTECT MODE VERSION
  5. ;    Hard Disk version
  6. ;    1989/90 by YUJI KIDA
  7. ;
  8. .386P
  9. pmode    segment para public use32
  10.     assume    cs:pmode,ds:pmode
  11.  
  12.     include    mpqshd.h
  13.  
  14.     org    100h
  15. start:
  16.  
  17. pmodesetR1R2:
  18.     mov    ax,10h
  19.     mov    ds,ax
  20.     mov    es,ax
  21.     mov    fs,ax
  22.     mov    gs,ax
  23.  
  24.     ; loop for primes
  25.  
  26.     mov    esi,primeadr+2*primeunitbytes    ;skip sign & 2
  27.     xor    ecx,ecx
  28.     mov    cx,ds:[_primes]
  29.     sub    cx,2        ;skip sign & 2
  30.     mov    ebx,2
  31. align 4
  32. R1R2loop:
  33.     push    ecx
  34.     xor    eax,eax
  35.     mov    ax,[esi]
  36.     add    ebx,eax
  37.     call    setparam
  38.     add    esi,primeunitbytes
  39.     pop    ecx
  40.     loop    R1R2loop
  41.  
  42.     ; return to real mode
  43.  
  44.     db    0eah
  45.     dd    104h        ;32 bit offset
  46.     dw    18h        ;gdt_code16 - gdttbl
  47.  
  48.  
  49.     ;data structure
  50.     ; prime diff    2bytes
  51.     ; log(P)     2bytes(higher=0)
  52.     ; sqrt(WN) @ P    4bytes
  53.     ; start1    4 bytes
  54.     ; start2    4 bytes
  55.     ; ( total    10h bytes=primeunitbytes)
  56.  
  57.     ; calc parameters for each prime
  58. setparam:
  59.     push    esi
  60.     mov    esi,_A2
  61.     call    longmod_bx
  62.     mov    eax,edx
  63.     call    ax_modinv_bx
  64.     mov    ds:[_MIA2P],eax    ;set 2A @ P
  65.  
  66.     mov    esi,_B
  67.     call    longmod_bx        ;edx = B @ P
  68.     pop    esi
  69.  
  70.     mov    eax,[esi+4]
  71.     add    edx,eax
  72.     cmp    edx,ebx
  73.     jbe    setparamj1
  74.     sub    edx,ebx
  75. setparamj1:
  76.     mov    eax,ebx
  77.     sub    eax,edx            ;(-B-R)@P
  78.  
  79.     mul    dword ptr ds:[_MIA2P]
  80.     div    ebx            ;edx = (-B-R)@P/2A@P
  81.  
  82.     mov    eax,edx
  83.     add    eax,ds:[_sievewidth]
  84.     xor    edx,edx
  85.     div    ebx
  86.     mov    [esi+8],edx        ;((-B-R)@P/2A+M)@P
  87.  
  88.     mov    eax,[esi+4]
  89.     shl    eax,1
  90.     mul    dword ptr ds:[_MIA2P]    ;2R/2A
  91.     div    ebx            ;edx = 2R/2A@P
  92.     add    edx,[esi+8]
  93.     cmp    edx,ebx
  94.     jb    setparamj3
  95.     sub    edx,ebx
  96. setparamj3:
  97.     add    edx,ds:[_sievetop]
  98.     mov    [esi+12],edx        ;((-B+R)@P/2A+M)@P
  99.     mov    eax,[esi+8]
  100.     add    eax,ds:[_sievetop]
  101.     mov    [esi+8],eax
  102.     ret
  103.  
  104.  
  105.     org    280h
  106.  
  107.     ; * sieve process
  108.  
  109. pmodesieve:
  110.     mov    ax,10h
  111.     mov    ds,ax
  112.     mov    es,ax
  113.  
  114.     ; set initial value
  115.  
  116.     push    ebp
  117.     mov    ebp,ds:[_sieveBsize]
  118.  
  119.     mov    edi,ds:[_sievetop]
  120.     mov    ecx,ebp
  121.     shr    ecx,2
  122.     mov    eax,ds:[_inilog]
  123.     rep    stosd
  124.  
  125.     mov    edx,ds:[_sieveover]
  126.  
  127.     ; sieve main1 start
  128.  
  129.     mov    esi,primeadr+2*primeunitbytes    ;skip sign & 2
  130. ;    xor    ecx,ecx
  131.     movzx    ecx,word ptr ds:[_primes]
  132.     sub    cx,ds:[_primes1]    ;cut primes >= sieveXsize
  133.     sub    cx,ds:[_primes2]    ;cut primes >= sieveBsize
  134.     sub    cx,2            ;skip sign & 2
  135.     mov    ebx,2
  136. align 4
  137. primeloop:
  138.     push    ecx
  139. ;    xor    eax,eax
  140.     movzx    eax,word ptr [esi]
  141.     add    ebx,eax
  142.  
  143.     mov    eax,ebx
  144.     shl    eax,sieveRepLog
  145.     sub    eax,ebx
  146.     mov    ecx,edx
  147.     sub    ecx,eax        ;ecx = sieveover - (sieveRep-1)*prime
  148.  
  149.     mov    al,[esi+2]        ;log
  150.  
  151.     mov    edi,[esi+8]
  152. align 4
  153. setlogplp1:
  154.   rept    sieveRep
  155.     sub    [edi],al
  156.     add    edi,ebx
  157.   endm
  158.     cmp    edi,ecx
  159.     jb    setlogplp1
  160.  
  161.   rept    sieveRep-1
  162.     cmp    edi,edx
  163.     jae    short setlogpskip1
  164.     sub    [edi],al
  165.     add    edi,ebx
  166.   endm
  167. align 4
  168. setlogpskip1:
  169.     sub    edi,ebp            ;ds:[_sieveBsize]
  170.     mov    [esi+8],edi
  171.  
  172.     mov    edi,[esi+12]
  173. align 4
  174. setlogplp2:
  175.   rept    sieveRep
  176.     sub    [edi],al
  177.     add    edi,ebx
  178.   endm
  179.     cmp    edi,ecx
  180.     jb    setlogplp2
  181.  
  182.   rept    sieveRep-1
  183.     cmp    edi,edx
  184.     jae    short setlogpskip2
  185.     sub    [edi],al
  186.     add    edi,ebx
  187.   endm
  188. align 4
  189. setlogpskip2:
  190.     sub    edi,ebp            ;ds:[_sieveBsize]
  191.     mov    [esi+12],edi
  192.  
  193.     add    esi,primeunitbytes
  194.     pop    ecx
  195.     dec    ecx
  196.     jnz    primeloop
  197.  
  198.     ; sieve main1 end
  199.  
  200.     ; sieve main2 start
  201.  
  202.     mov    cx,ds:[_primes1]
  203.     or    cx,cx
  204.     jz    sievemain3
  205. align 4
  206. primeloop2:
  207. ;    xor    eax,eax
  208.     movzx    eax,word ptr [esi]
  209.     add    ebx,eax
  210.  
  211.     mov    al,[esi+2]        ;log
  212.  
  213.     mov    edi,[esi+8]
  214.   rept    sieveRep-1
  215.     sub    [edi],al
  216.     add    edi,ebx
  217.     cmp    edi,edx
  218.     jae    short setlogpskip3
  219.   endm
  220.     sub    [edi],al
  221.     add    edi,ebx
  222. align 4
  223. setlogpskip3:
  224.     sub    edi,ebp            ;ds:[_sieveBsize]
  225.     mov    [esi+8],edi
  226.  
  227.     mov    edi,[esi+12]
  228.  
  229.   rept    sieveRep-1
  230.     sub    [edi],al
  231.     add    edi,ebx
  232.     cmp    edi,edx
  233.     jae    short setlogpskip4
  234.   endm
  235.     sub    [edi],al
  236.     add    edi,ebx
  237. align 4
  238. setlogpskip4:
  239.     sub    edi,ebp            ;ds:[_sieveBsize]
  240.     mov    [esi+12],edi
  241.  
  242.     add    esi,primeunitbytes
  243.     dec    ecx
  244.     jnz    primeloop2
  245.  
  246.  
  247.     ; sieve main2 end
  248.  
  249.     ; sieve main3 start
  250.  
  251. sievemain3:
  252.     mov    cx,ds:[_primes2]
  253.     jcxz    short sievedone
  254. align 4
  255. primeloop3:
  256. ;    xor    eax,eax
  257.     movzx    eax,word ptr [esi]
  258.     add    ebx,eax
  259.  
  260.     mov    edi,[esi+8]
  261.     cmp    edi,edx
  262.     jae    short setlogpskip5
  263.     mov    al,[esi+2]        ;log
  264.     sub    [edi],al
  265.     add    edi,ebx
  266. setlogpskip5:
  267.     sub    edi,ebp            ;ds:[_sieveBsize]
  268.     mov    [esi+8],edi
  269.  
  270.     mov    edi,[esi+12]
  271.     cmp    edi,edx
  272.     jae    short setlogpskip6
  273.     mov    al,[esi+2]        ;log
  274.     sub    [edi],al
  275.     add    edi,ebx
  276. setlogpskip6:
  277.     sub    edi,ebp            ;ds:[_sieveBsize]
  278.     mov    [esi+12],edi
  279.  
  280.     add    esi,primeunitbytes
  281.     loop    primeloop3
  282.  
  283.     ; sieve main3 end
  284.  
  285. sievedone:
  286.     mov    al,ds:[_cutlog]
  287.     mov    edx,ds:[_sievetop]
  288.  
  289.     mov    ebx,sieveansarea
  290.     mov    word ptr [ebx],0
  291.     mov    esi,sieveansarea+4
  292.     mov    edi,edx            ;ds:[_sievetop]
  293.     mov    ecx,ebp            ;ds:[_sieveBsize]
  294. align 4
  295. sieveanslp:
  296.     scasb
  297.     ja    short sieveansfind
  298. sieveansnext:
  299.     loop    sieveanslp
  300.  
  301.     ; return to real mode
  302. sieveansret:
  303.     pop    ebp
  304.  
  305.     db    0eah
  306.     dd    104h        ;32 bit offset
  307.     dw    18h        ;gdt_code16 - gdttbl
  308.  
  309.  
  310. sieveansfind:
  311.     sub    edi,edx        ;ds:[_sievetop]
  312.     dec    edi
  313.     mov    [esi],edi    ;result
  314.     add    edi,edx        ;ds:[_sievetop]
  315.     inc    edi
  316.     add    esi,4
  317.     inc    word ptr [ebx]    ;# of results
  318.     jmp    sieveansnext
  319.  
  320.  
  321.  
  322.     org    700h
  323. decompose:
  324.     mov    ax,10h
  325.     mov    ds,ax
  326.     mov    es,ax
  327.  
  328.     push    ebp
  329.  
  330. ;    xor    eax,eax
  331.     movzx    eax,word ptr ds:[_absQ+2]
  332.     shl    eax,4
  333. ;    xor    esi,esi
  334.     movzx    esi,word ptr ds:[_absQ]
  335.     add    esi,eax        ;absolute adr of W#
  336.     push    esi        ;*
  337.  
  338.     mov    ebx,_W
  339.     mov    edi,ebx        ;set in _W by dword format
  340.     xor    eax,eax
  341.     lodsw
  342.     mov    ecx,eax
  343.     inc    eax
  344.     shr    eax,1
  345.     stosd
  346.     rep    movsw
  347.     xor    eax,eax
  348.     stosw
  349.  
  350.     ; divide by p=2
  351. decomp2:
  352.     cmp    dword ptr [ebx+4],0
  353.     jne    short decomp4
  354.     mov    ecx,[ebx]
  355.     dec    ecx
  356.     mov    [ebx],ecx
  357.     lea    edi,[ebx+4]
  358.     lea    esi,[edi+4]
  359.     rep    movsd
  360.     jmp    decomp2
  361. decomp4:
  362.     std
  363.  
  364.     mov    eax,[ebx+4]
  365.     mov    ebp,1
  366. decomp5:
  367.     shl    ebp,1
  368.     shr    eax,1
  369.     jnc    decomp5
  370.     shr    ebp,1
  371.     cmp    ebp,1
  372.     je    short decomp8
  373.  
  374.     mov    esi,ebx
  375.     mov    eax,[esi]
  376.     mov    ecx,eax
  377.     shl    eax,2
  378.     add    esi,eax        ;highest dword adr
  379.     xor    edx,edx
  380.     lodsd
  381.     div    ebp
  382.     push    eax        ;new highest value
  383.     jmp    short decomp7
  384. align 4
  385. decomp6:
  386.     lodsd
  387.     div    ebp
  388. decomp7:
  389.     mov    [esi+4],eax
  390.     loop    decomp6
  391.     pop    eax
  392.     or    eax,eax
  393.     jnz    short decomp75
  394.     dec    dword ptr [ebx]
  395. decomp75:
  396.     mov    eax,[ebx]
  397.     or    eax,[ebx+4]
  398.     dec    eax
  399.     jz    short decompout    ;if result=1
  400.  
  401.     ; divide by odd primes
  402. decomp8:
  403.     mov    eax,ds:[_sieveConst]
  404.     sub    eax,ds:[_result]
  405.     mov    ds:[_result],ebx
  406.     mov    ebx,eax
  407.  
  408.     mov    edi,primeadr+2*primeunitbytes    ;skip sign & 2
  409.     mov    ecx,ds:[_primes]
  410.     sub    ecx,2        ;skip sign & 2
  411.     mov    ebp,2
  412.  
  413. decomp10:
  414. ;    xor    eax,eax
  415.     movzx    eax,word ptr [edi]
  416.     add    ebp,eax
  417.  
  418.     xor    edx,edx
  419.     mov    eax,[edi+8]
  420.     add    eax,ebx
  421.     div    ebp
  422.     or    edx,edx
  423.     jz    short godecomp    ;divide exactly
  424.  
  425.     xor    edx,edx
  426.     mov    eax,[edi+12]
  427.     add    eax,ebx
  428.     div    ebp
  429.     or    edx,edx
  430.     jz    short godecomp    ;divide exactly
  431. decomp40:
  432.     add    edi,primeunitbytes
  433.     loop    decomp10
  434.     mov    ebx,ds:[_result]
  435.  
  436. decompout:
  437.     cld
  438.  
  439.     mov    esi,ebx
  440.     pop    ebx        ;*transfer to 16bit format
  441.     mov    edi,ebx
  442.     lodsd
  443.     shl    eax,1
  444.     mov    ecx,eax        ;word length
  445.     stosw
  446.     rep    movsw
  447.     cmp    word ptr [edi-2],0
  448.     jne    short decomp50        ;if highest not 0
  449.     dec    word ptr [ebx]
  450. decomp50:
  451.     pop    ebp
  452.  
  453.     ; return to real mode
  454.  
  455.     db    0eah
  456.     dd    104h        ;32 bit offset
  457.     dw    18h        ;gdt_code16 - gdttbl
  458.  
  459.  
  460. decomp90:
  461.     mov    esi,ebx
  462.     mov    eax,[esi]
  463.     mov    ecx,eax
  464.     shl    eax,2
  465.     add    esi,eax        ;highest dword adr
  466.     xor    edx,edx
  467. align 4
  468. decomp95:
  469.     lodsd
  470.     div    ebp
  471.     loop    decomp95
  472.     or    edx,edx
  473.     jz    short decomp100
  474.     pop    ecx
  475.     pop    ebx
  476.     jmp    decomp40
  477. align 4
  478. godecomp:
  479.     push    ebx
  480.     push    ecx
  481.     mov    ebx,ds:[_result]
  482. decomp100:
  483.     mov    esi,ebx
  484.     mov    eax,[esi]
  485.     mov    ecx,eax
  486.     shl    eax,2
  487.     add    esi,eax        ;highest dword adr
  488.     xor    edx,edx
  489.     lodsd
  490.     div    ebp
  491.     push    eax        ;new highest value
  492.     jmp    short decomp120
  493. align 4
  494. decomp110:
  495.     lodsd
  496.     div    ebp
  497. decomp120:
  498.     mov    [esi+4],eax
  499.     loop    decomp110
  500.     pop    eax
  501.     or    eax,eax
  502.     jnz    short decomp130    ;if same length
  503.     dec    dword ptr [ebx]
  504. decomp130:
  505.     mov    eax,[ebx]
  506.     or    eax,[ebx+4]
  507.     dec    eax
  508.     jz    short decomp140    ;if result=1
  509.     cmp    ebp,1024
  510.     jbe    decomp90    ;check divisible ^2,^3 ?
  511.     pop    ecx
  512.     pop    ebx
  513.     jmp    decomp40
  514. decomp140:
  515.     pop    eax        ;dummy
  516.     pop    eax        ;dummy
  517.     jmp    decompout    ;if result=1
  518.  
  519.     public    decompend
  520. decompend:
  521.  
  522.     org    900h
  523. ;
  524. ; quick sort
  525. ;
  526. _s    equ    0
  527. _e    equ    2
  528. _i    equ    4
  529. _j    equ    6
  530. _pivot    equ    8        ;4bytes
  531.  
  532. qsort:
  533.     mov    ax,10h
  534.     mov    ds,ax
  535.     mov    es,ax
  536.  
  537.     mov    bx,1
  538.     call    qsortmain
  539.  
  540.     ; return to real mode
  541.  
  542.     db    0eah
  543.     dd    104h        ;32 bit offset
  544.     dw    18h        ;gdt_code16 - gdttbl
  545.  
  546.  
  547.     org    0a00h
  548. ;
  549. ; insertion sort
  550. ;
  551. _s    equ    0
  552. _e    equ    2
  553. _i    equ    4
  554. _j    equ    6
  555. _ww    equ    8    ;4 bytes
  556. _m1    equ    12    ;4 bytes
  557.  
  558. isort:
  559.     mov    ax,10h
  560.     mov    ds,ax
  561.     mov    es,ax
  562.  
  563.     push    bp
  564.     sub    sp,16
  565.     mov    bp,sp
  566.     mov    bx,1
  567.     mov    [bp+_s],bx
  568.     mov    [bp+_e],cx    ;passed from real mode
  569.     mov    ax,bx
  570.     dec    ax
  571.     call    getlpv
  572.     mov    [bp+_m1],eax
  573.  
  574.     mov    cx,[bp+_e]
  575.     mov    ax,[bp+_s]
  576.     sub    cx,ax
  577.     inc    ax
  578.     mov    [bp+_i],ax
  579. isort10:
  580.     push    cx
  581.     mov    ax,[bp+_i]
  582.     call    getlpv
  583.     mov    edx,eax
  584.     mov    [bp+_ww],eax
  585.     mov    ax,[bp+_s]
  586.     dec    ax
  587.     call    putlpv
  588.  
  589.     mov    ax,[bp+_i]
  590.     dec    ax
  591.     mov    [bp+_j],ax
  592.  
  593.   ;while
  594. isort40:
  595.     mov    ax,[bp+_j]
  596.     call    getlpv
  597.     cmp    eax,[bp+_ww]
  598.     jbe    isort50
  599.  
  600.     xor    eax,eax
  601.     mov    ax,[bp+_j]
  602.     shl    eax,1
  603.     add    eax,ds:[_lpvindexadr]
  604.     mov    esi,eax
  605.     lea    edi,[esi+2]
  606.     mov    ax,[esi]
  607.     xchg    ax,[edi]
  608.     mov    [esi],ax
  609.     dec    word ptr [bp+_j]
  610.     jmp    isort40
  611.   ;wend
  612.  
  613. isort50:
  614.     pop    cx
  615.     inc    word ptr [bp+_i]
  616.     loop    isort10
  617.  
  618.     mov    ax,[bp+_s]
  619.     dec    ax
  620.     mov    edx,[bp+_m1]
  621.     call    putlpv
  622.  
  623.     add    sp,16
  624.     pop    bp
  625.  
  626.     ; return to real mode
  627.  
  628.     db    0eah
  629.     dd    104h        ;32 bit offset
  630.     dw    18h        ;gdt_code16 - gdttbl
  631.  
  632.  
  633. ;
  634. ; initialize for INIT
  635. ;
  636.  
  637.     org    0b00h
  638.  
  639.     mov    ax,10h
  640.     mov    fs,ax
  641.     mov    gs,ax
  642.  
  643.     ; return to real mode
  644.  
  645.     db    0eah
  646.     dd    104h        ;32 bit offset
  647.     dw    18h        ;gdt_code16 - gdttbl
  648.  
  649.  
  650. ;
  651. ;* subroutines
  652. ;
  653. getlpv:
  654.     and    eax,0000ffffh
  655.     shl    eax,1
  656.     add    eax,ds:[_lpvindexadr]
  657.     mov    ebx,eax
  658.     xor    eax,eax
  659.     mov    ax,[ebx]
  660.     mov    edx,t_byte
  661.     mul    edx
  662.     add    eax,ds:[_lpvdataadr]
  663.     mov    esi,eax
  664.     mov    eax,[esi]
  665.     ret
  666.  
  667. putlpv:
  668.     push    edx
  669.     and    eax,0000ffffh
  670.     shl    eax,1
  671.     add    eax,ds:[_lpvindexadr]
  672.     mov    ebx,eax
  673.     xor    eax,eax
  674.     mov    ax,[ebx]
  675.     mov    edx,t_byte
  676.     mul    edx
  677.     add    eax,ds:[_lpvdataadr]
  678.     mov    esi,eax
  679.     pop    eax
  680.     mov    [esi],eax
  681.     ret
  682.  
  683. ;
  684. ;  long integer @ 32bit integer
  685. ;  edx = [esi] @ ebx
  686. ;  [esi] > 0 must not be 0
  687. ; destroy : eax,ecx,edx
  688.  
  689. longmod_bx:
  690.     mov    eax,[esi]
  691.     and    eax,07fffh
  692.     mov    ecx,eax
  693.     shl    eax,2
  694.     add    esi,eax
  695.     xor    edx,edx
  696.     std
  697. align 4
  698. longmodlp:
  699.     lodsd
  700.     div    ebx
  701.     loop    longmodlp
  702.     cld
  703.     ret
  704.  
  705. ;
  706. ; inverse modulo prime
  707. ; 
  708. ; inp : eax
  709. ; out : eax = 1/eax mod ebx
  710. ; destroy : ecx,esi,edi
  711.  
  712. ax_modinv_bx:
  713.     cmp    eax,1
  714.     je    modinvret
  715.     mov    ecx,ebx
  716.     cmp    eax,ebx
  717.     jb    modinv10
  718.     xor    edx,edx
  719.     div    ebx
  720.     mov    eax,edx
  721.     cmp    eax,1
  722.     je    modinvret
  723. modinv10:
  724.     xchg    eax,ecx
  725.     xor    esi,esi        ;coef1
  726.     mov    edi,1        ;coef2
  727. modinv20:
  728.     xor    edx,edx
  729.     div    ecx
  730.     push    edx        ;remainder
  731.     push    edi        ;coef2
  732.     mul    edi
  733.     div    ebx
  734.     mov    eax,esi
  735.     sub    eax,edx
  736.     jae    modinv30
  737.     add    eax,ebx
  738. modinv30:
  739.     mov    edi,eax        ;new coef2=coef1-quotient*coef2
  740.     pop    esi        ;new coef1=old coef2
  741.     mov    eax,ecx
  742.     pop    ecx
  743.     cmp    ecx,1
  744.     jne    modinv20    ;GCD must 1 otherwise endlessloop
  745.     mov    eax,edi
  746. modinvret:
  747.     ret
  748.  
  749.  
  750. qsortmain:                ;bx=S,cx=E
  751.     push    ebp
  752.     sub    sp,12
  753.  
  754.     mov    bp,sp
  755.     mov    [bp+_s],bx
  756.     mov    [bp+_i],bx
  757.     mov    [bp+_e],cx
  758.     mov    [bp+_j],cx
  759.     mov    ax,bx
  760.     add    ax,10
  761.     cmp    ax,cx
  762.     jae    qsortret
  763.     sub    ax,10
  764.     add    ax,cx
  765.     shr    ax,1        ;ax=(E+S)/2
  766.     call    getlpv
  767.     mov    [bp+_pivot],eax
  768. qsort10:
  769.     mov    ax,[bp+_i]
  770.     call    getlpv
  771.     cmp    eax,[bp+_pivot]
  772.     jnb    qsort20
  773.     inc    word ptr [bp+_i]
  774.     jmp    qsort10
  775. qsort20:            
  776.     mov    ax,[bp+_j]
  777.     call    getlpv
  778.     cmp    eax,[bp+_pivot]
  779.     jna    qsort30
  780.     dec    word ptr [bp+_j]
  781.     jmp    qsort20
  782. qsort30:
  783.     mov    ax,[bp+_i]
  784.     cmp    ax,[bp+_j]
  785.     ja    qsort50
  786.     and    eax,0000ffffh
  787.     shl    eax,1
  788.     add    eax,ds:[_lpvindexadr]
  789.     mov    esi,eax
  790.  
  791.     mov    ax,[bp+_j]
  792.     and    eax,0000ffffh
  793.     shl    eax,1
  794.     add    eax,ds:[_lpvindexadr]
  795.     mov    edi,eax
  796.  
  797.     mov    ax,[esi]
  798.     xchg    ax,[edi]
  799.     mov    [esi],ax
  800.     inc    word ptr [bp+_i]
  801.     dec    word ptr [bp+_j]
  802. qsort50:
  803.     mov    ax,[bp+_i]
  804.     cmp    ax,[bp+_j]
  805.     jbe    qsort10
  806.     mov    bx,[bp+_s]
  807.     mov    cx,[bp+_j]
  808.     call    qsortmain
  809.     mov    bx,[bp+_i]
  810.     mov    cx,[bp+_e]
  811.     call    qsortmain
  812. qsortret:
  813.     add    sp,12
  814.     pop    ebp
  815.     ret
  816.  
  817. pmode    ends
  818.  
  819.  
  820. end    start
  821.