--- JMFF.NRLIB/JMFF.lsp	2024-12-22 02:10:40.362641087 +0100
+++ JMFF.NRLIB.ppack/JMFF.lsp	2024-12-22 02:04:51.092696940 +0100
@@ -1,127 +1,120 @@
 
-(PUT '|JMFF1;jlApplyFunction;S2Jf;1| '|SPADreplace| '|jl_dbl_function_dbl|) 
+(PUT '|JMFF;jlApplyFunction;S2R;1| '|SPADreplace| '|jl_dbl_function_dbl|) 
 
-(SDEFUN |JMFF1;jlApplyFunction;S2Jf;1|
-        ((|func| (|String|)) (|a| (|JuliaFloat64|)) (% (|JuliaFloat64|)))
+(SDEFUN |JMFF;jlApplyFunction;S2R;1| ((|func| (|String|)) (|a| (R)) (% (R)))
         (|jl_dbl_function_dbl| |func| |a|)) 
 
-(PUT '|JMFF1;jlApplyFunction;S3Jf;2| '|SPADreplace| '|jl_dbl_function_dbl_dbl|) 
+(PUT '|JMFF;jlApplyFunction;S3R;2| '|SPADreplace| '|jl_dbl_function_dbl_dbl|) 
 
-(SDEFUN |JMFF1;jlApplyFunction;S3Jf;2|
-        ((|func| (|String|)) (|a| (|JuliaFloat64|)) (|b| (|JuliaFloat64|))
-         (% (|JuliaFloat64|)))
+(SDEFUN |JMFF;jlApplyFunction;S3R;2|
+        ((|func| (|String|)) (|a| (R)) (|b| (R)) (% (R)))
         (|jl_dbl_function_dbl_dbl| |func| |a| |b|)) 
 
-(PUT '|JMFF1;jlApplyFunction;S4Jf;3| '|SPADreplace|
+(PUT '|JMFF;jlApplyFunction;S4R;3| '|SPADreplace|
      '|jl_dbl_function_dbl_dbl_dbl|) 
 
-(SDEFUN |JMFF1;jlApplyFunction;S4Jf;3|
-        ((|func| (|String|)) (|a| (|JuliaFloat64|)) (|b| (|JuliaFloat64|))
-         (|c| (|JuliaFloat64|)) (% (|JuliaFloat64|)))
+(SDEFUN |JMFF;jlApplyFunction;S4R;3|
+        ((|func| (|String|)) (|a| (R)) (|b| (R)) (|c| (R)) (% (R)))
         (|jl_dbl_function_dbl_dbl_dbl| |func| |a| |b| |c|)) 
 
-(PUT '|JMFF1;jlApplyFunction;S2Jf;4| '|SPADreplace| '|jl_flt_function_flt|) 
+(PUT '|JMFF;jlApplyFunction;S2R;4| '|SPADreplace| '|jl_flt_function_flt|) 
 
-(SDEFUN |JMFF1;jlApplyFunction;S2Jf;4|
-        ((|func| (|String|)) (|a| (|JuliaFloat32|)) (% (|JuliaFloat32|)))
+(SDEFUN |JMFF;jlApplyFunction;S2R;4| ((|func| (|String|)) (|a| (R)) (% (R)))
         (|jl_flt_function_flt| |func| |a|)) 
 
-(PUT '|JMFF1;jlApplyFunction;S3Jf;5| '|SPADreplace| '|jl_flt_function_flt_flt|) 
+(PUT '|JMFF;jlApplyFunction;S3R;5| '|SPADreplace| '|jl_flt_function_flt_flt|) 
 
-(SDEFUN |JMFF1;jlApplyFunction;S3Jf;5|
-        ((|func| (|String|)) (|a| (|JuliaFloat32|)) (|b| (|JuliaFloat32|))
-         (% (|JuliaFloat32|)))
+(SDEFUN |JMFF;jlApplyFunction;S3R;5|
+        ((|func| (|String|)) (|a| (R)) (|b| (R)) (% (R)))
         (|jl_flt_function_flt_flt| |func| |a| |b|)) 
 
-(PUT '|JMFF1;jlApplyFunction;S4Jf;6| '|SPADreplace|
-     '(XLAM (|func| |a| |b| |c|)
-       (|jl_flt_function_flt_flt_flt| |func| |a| |c|))) 
-
-(SDEFUN |JMFF1;jlApplyFunction;S4Jf;6|
-        ((|func| (|String|)) (|a| (|JuliaFloat32|)) (|b| (|JuliaFloat32|))
-         (|c| (|JuliaFloat32|)) (% (|JuliaFloat32|)))
-        (|jl_flt_function_flt_flt_flt| |func| |a| |c|)) 
+(PUT '|JMFF;jlApplyFunction;S4R;6| '|SPADreplace|
+     '|jl_flt_function_flt_flt_flt|) 
+
+(SDEFUN |JMFF;jlApplyFunction;S4R;6|
+        ((|func| (|String|)) (|a| (R)) (|b| (R)) (|c| (R)) (% (R)))
+        (|jl_flt_function_flt_flt_flt| |func| |a| |b| |c|)) 
 
 (DECLAIM (NOTINLINE |JuliaMachineFloatFunctions;|)) 
 
-(DEFUN |JuliaMachineFloatFunctions| ()
+(DEFUN |JuliaMachineFloatFunctions| (#1=#:G1002)
   (SPROG NIL
-         (PROG (#1=#:G660)
+         (PROG (#2=#:G1003)
            (RETURN
             (COND
-             ((LETT #1#
-                    (HGET |$ConstructorCache| '|JuliaMachineFloatFunctions|))
-              (|CDRwithIncrement| (CDAR #1#)))
+             ((LETT #2#
+                    (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
+                                               (HGET |$ConstructorCache|
+                                                     '|JuliaMachineFloatFunctions|)
+                                               '|domainEqualList|))
+              (|CDRwithIncrement| #2#))
              ('T
               (UNWIND-PROTECT
-                  (PROG1
-                      (CDDAR
-                       (HPUT |$ConstructorCache| '|JuliaMachineFloatFunctions|
-                             (LIST
-                              (CONS NIL
-                                    (CONS 1
-                                          (|JuliaMachineFloatFunctions;|))))))
-                    (LETT #1# T))
+                  (PROG1 (|JuliaMachineFloatFunctions;| #1#) (LETT #2# T))
                 (COND
-                 ((NOT #1#)
+                 ((NOT #2#)
                   (HREM |$ConstructorCache|
                         '|JuliaMachineFloatFunctions|)))))))))) 
 
-(DEFUN |JuliaMachineFloatFunctions;| ()
-  (SPROG ((|dv$| NIL) (% NIL) (|pv$| NIL))
+(DEFUN |JuliaMachineFloatFunctions;| (|#1|)
+  (SPROG ((|pv$| NIL) (% NIL) (|dv$| NIL) (DV$1 NIL))
          (PROGN
-          (LETT |dv$| '(|JuliaMachineFloatFunctions|))
-          (LETT % (GETREFV 15))
+          (LETT DV$1 (|devaluate| |#1|))
+          (LETT |dv$| (LIST '|JuliaMachineFloatFunctions| DV$1))
+          (LETT % (GETREFV 11))
           (QSETREFV % 0 |dv$|)
           (QSETREFV % 3 (LETT |pv$| (|buildPredVector| 0 0 NIL)))
-          (|haddProp| |$ConstructorCache| '|JuliaMachineFloatFunctions| NIL
-                      (CONS 1 %))
+          (|haddProp| |$ConstructorCache| '|JuliaMachineFloatFunctions|
+                      (LIST DV$1) (CONS 1 %))
           (|stuffDomainSlots| %)
+          (QSETREFV % 6 |#1|)
           (SETF |pv$| (QREFELT % 3))
+          (COND
+           ((|domainEqual| |#1| (|JuliaFloat64|))
+            (PROGN
+             (QSETREFV % 8
+                       (CONS (|dispatchFunction| |JMFF;jlApplyFunction;S2R;1|)
+                             %))
+             (QSETREFV % 9
+                       (CONS (|dispatchFunction| |JMFF;jlApplyFunction;S3R;2|)
+                             %))
+             (QSETREFV % 10
+                       (CONS (|dispatchFunction| |JMFF;jlApplyFunction;S4R;3|)
+                             %))))
+           ('T
+            (PROGN
+             (QSETREFV % 8
+                       (CONS (|dispatchFunction| |JMFF;jlApplyFunction;S2R;4|)
+                             %))
+             (QSETREFV % 9
+                       (CONS (|dispatchFunction| |JMFF;jlApplyFunction;S3R;5|)
+                             %))
+             (QSETREFV % 10
+                       (CONS (|dispatchFunction| |JMFF;jlApplyFunction;S4R;6|)
+                             %)))))
           %))) 
 
 (MAKEPROP '|JuliaMachineFloatFunctions| '|infovec|
           (LIST
-           '#(NIL NIL NIL NIL NIL NIL (|JuliaFloat64|) (|String|)
-              |JMFF1;jlApplyFunction;S2Jf;1| |JMFF1;jlApplyFunction;S3Jf;2|
-              |JMFF1;jlApplyFunction;S4Jf;3| (|JuliaFloat32|)
-              |JMFF1;jlApplyFunction;S2Jf;4| |JMFF1;jlApplyFunction;S3Jf;5|
-              |JMFF1;jlApplyFunction;S4Jf;6|)
-           '#(|jlApplyFunction| 0) 'NIL
+           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|String|)
+              (0 . |jlApplyFunction|) (6 . |jlApplyFunction|)
+              (13 . |jlApplyFunction|))
+           '#(|jlApplyFunction| 21) 'NIL
            (CONS (|makeByteWordVec2| 1 '(0))
                  (CONS '#(NIL)
                        (CONS
                         '#((|Join|
                             (|mkCategory|
                              (LIST
-                              '((|jlApplyFunction|
-                                 ((|JuliaFloat64|) (|String|)
-                                  (|JuliaFloat64|)))
-                                T)
-                              '((|jlApplyFunction|
-                                 ((|JuliaFloat64|) (|String|) (|JuliaFloat64|)
-                                  (|JuliaFloat64|)))
-                                T)
-                              '((|jlApplyFunction|
-                                 ((|JuliaFloat64|) (|String|) (|JuliaFloat64|)
-                                  (|JuliaFloat64|) (|JuliaFloat64|)))
-                                T)
-                              '((|jlApplyFunction|
-                                 ((|JuliaFloat32|) (|String|)
-                                  (|JuliaFloat32|)))
-                                T)
-                              '((|jlApplyFunction|
-                                 ((|JuliaFloat32|) (|String|) (|JuliaFloat32|)
-                                  (|JuliaFloat32|)))
+                              '((|jlApplyFunction| (|#1| (|String|) |#1|)) T)
+                              '((|jlApplyFunction| (|#1| (|String|) |#1| |#1|))
                                 T)
                               '((|jlApplyFunction|
-                                 ((|JuliaFloat32|) (|String|) (|JuliaFloat32|)
-                                  (|JuliaFloat32|) (|JuliaFloat32|)))
+                                 (|#1| (|String|) |#1| |#1| |#1|))
                                 T))
                              (LIST) NIL NIL)))
-                        (|makeByteWordVec2| 14
-                                            '(3 0 11 7 11 11 13 4 0 11 7 11 11
-                                              11 14 2 0 11 7 11 12 3 0 6 7 6 6
-                                              9 4 0 6 7 6 6 6 10 2 0 6 7 6
-                                              8)))))
+                        (|makeByteWordVec2| 10
+                                            '(2 0 6 7 6 8 3 0 6 7 6 6 9 4 0 6 7
+                                              6 6 6 10 3 0 6 7 6 6 9 4 0 6 7 6
+                                              6 6 10 2 0 6 7 6 8)))))
            '|lookupComplete|))