Clean up the operation dependency, to get a better approximation of the types/operations needed.

generate.hs

@@ -35,6 +35,7 @@ data Operation = Add
                | SigConvert Int
                | EGCD
                | ModInv
+               | RSA
  deriving (Eq, Ord, Show)
 
 data Requirement = Req Int Operation
@@ -43,47 +44,91 @@ data Requirement = Req Int Operation
 data Need = Need Operation (Int -> [Requirement])
 
 needs :: [Need]
-needs = [ Need ModExp      (\ size -> [Req size ModMul
+needs = [ Need RSA         (\ size -> [Req (size `div` 2) Sub,
-                                      ,Req size ModSq
+                                       Req (size `div` 2) Mul,
-                                      ,Req size Barretts])
+                                       Req size           BaseOps,
-        , Need ModSq       (\ size -> [Req (size * 2) Div
+                                       Req size           ModInv,
-                                      ,Req size Barretts
+                                       Req size           ModExp
-                                      ,Req size Square])
-        , Need ModMul      (\ size -> [Req size Mul
-                                      ,Req size Barretts
-                                      ,Req size (Convert (size * 2))
-                                      ,Req (size * 2) Div])
-        , Need Barretts    (\ size -> [Req (size + 64) BaseOps
-                                      ,Req size (Convert (size + 64))
-                                      ,Req (size + 64) (Convert ((size * 2) + 64))
-                                      ,Req size (Convert ((size * 2) + 64))
-                                      ,Req ((size * 2) + 64) Add
-                                      ,Req ((size * 2) + 64) Sub
-                                      ,Req (size + 64) Mul
-                                      ,Req (size * 2) (Convert ((size * 2) + 64))
-                                      ,Req ((size * 2) + 64) Shifts
-                                      ,Req ((size * 2) + 128) Shifts
-                                      ,Req ((size * 2) + 64) Div
-                                      ,Req (size + 64) (Convert (size * 2))
-                                      ,Req (size + 64) (Convert ((size * 2) + 128))
-                                      ,Req ((size * 2) + 64)
-                                           (Convert ((size * 2) + 128))
                                       ])
-        , Need Div         (\ size -> [Req size (Convert (size * 2))
+        , Need Add         (\ size -> [Req size BaseOps,
-                                      ,Req 192 BaseOps
+                                       Req (size + 64) BaseOps,
-                                      ,Req 384 BaseOps
+                                       Req size (Convert (size + 64))
-                                      ,Req 192 Mul
-                                      ,Req size Mul
-                                      ,Req size Shifts
-                                      ,Req (size * 2) Sub
                                       ])
-        , Need Mul         (\ size -> [Req (size * 2) BaseOps])
+        , Need Barretts    (\ size -> [Req size BaseOps,
-        , Need Sub         (\ size -> [Req size Add])
+                                       Req (size + 64) BaseOps,
-        , Need Add         (\ size -> [Req (size + 64) BaseOps
+                                       Req (size * 2) BaseOps,
-                                      ,Req size (Convert (size + 64))])
+                                       Req ((size * 2) + 64) BaseOps,
-        , Need ModInv      (\ size -> [Req size SignedBase,
+                                       Req size (Convert ((size * 2) + 64)),
-                                       Req size EGCD])
+                                       Req (size + 64) Mul,
-        , Need EGCD        (\ size -> [Req size BaseOps,
+                                       Req ((size * 2) + 64) Add,
+                                       Req ((size * 2) + 64) Sub,
+                                       Req (size + 64) (Convert ((size * 2) + 64)),
+                                       Req ((size * 2) + 64) (Convert ((size + 64) * 2)),
+                                       Req (size * 2) (Convert ((size * 2) + 64)),
+                                       Req (size + 64) (Convert ((size + 64) * 2)),
+                                       Req (size + 64) (Convert (size * 2)),
+                                       Req (size * 2) Shifts,
+                                       Req ((size + 64) * 2) Shifts,
+                                       Req ((size * 2) + 64) Div
+                                      ])
+        , Need Div         (\ size -> [Req size BaseOps,
+                                       Req (size * 2) BaseOps,
+                                       Req size (Convert (size * 2)),
+                                       Req (size * 2) Sub,
+                                       Req size Mul,
+                                       Req 192 BaseOps,
+                                       Req 192 Mul,
+                                       Req 384 BaseOps
+                                      ])
+        , Need ModExp      (\ size -> [Req size BaseOps,
+                                       Req size Barretts,
+                                       Req size ModSq,
+                                       Req size ModMul
+                                      ])
+        , Need ModMul      (\ size -> [Req size BaseOps,
+                                       Req (size * 2) BaseOps,
+                                       Req size Barretts,
+                                       Req size Mul
+                                      ])
+        , Need ModSq       (\ size -> [Req size BaseOps,
+                                       Req (size * 2) BaseOps,
+                                       Req size Barretts,
+                                       Req size Square,
+                                       Req (size * 2) Div,
+                                       Req size (Convert (size * 2))
+                                      ])
+        , Need Mul         (\ size -> [Req size BaseOps,
+                                       Req (size * 2) BaseOps,
+                                       Req size (Convert (size * 2))
+                                      ])
+        , Need Shifts      (\ size -> [Req size BaseOps
+                                      ])
+        , Need Square      (\ size -> [Req size BaseOps,
+                                       Req (size * 2) BaseOps
+                                      ])
+        , Need Sub         (\ size -> [Req size BaseOps
+                                      ])
+        , Need SignedAdd   (\ size -> [Req size SignedBase,
+                                       Req (size + 64) SignedBase,
+                                       Req (size + 64) BaseOps
+                                      ])
+        , Need SignedBase  (\ size -> [Req size BaseOps])
+        , Need SignedCmp   (\ size -> [Req size BaseOps])
+        , Need SignedShift (\ size -> [Req size SignedBase,
+                                       Req size BaseOps,
+                                       Req size Shifts,
+                                       Req size Add
+                                      ])
+        , Need SignedSub   (\ size -> [Req size SignedBase,
+                                       Req (size + 64) SignedBase,
+                                       Req (size + 64) BaseOps,
+                                       Req size Add,
+                                       Req size Sub,
+                                       Req size (Convert (size + 64)),
+                                       Req size (SigConvert (size + 64))
+                                      ])
+        , Need EGCD        (\ size -> [Req size SignedBase,
+                                       Req size BaseOps,
                                        Req (size + 64) SignedBase,
                                        Req size (SigConvert (size + 64)),
                                        Req (size + 64) SignedShift,
@@ -91,17 +136,77 @@ needs = [ Need ModExp      (\ size -> [Req size ModMul
                                        Req (size + 64) SignedSub,
                                        Req (size + 64) SignedCmp
                                        ])
-        , Need SignedShift (\ size -> [Req size Shifts, Req size Add])
+        , Need ModInv      (\ size -> [Req size BaseOps,
-        , Need SignedAdd   (\ size -> [Req size Sub,
-                                       Req (size + 64) Add,
                                        Req (size + 64) SignedBase,
-                                       Req size (SigConvert (size + 64))
+                                       Req (size + 64) BaseOps,
-                                       ])
+                                       Req size (Convert (size + 64)),
-        , Need SignedSub   (\ size -> [Req (size + 64) SignedBase,
+                                       Req size EGCD,
-                                       Req size (SigConvert (size + 64)),
+                                       Req (size + 64) SignedAdd,
-                                       Req size Sub
+                                       Req size Barretts
                                        ])
         ]
+-- needs = [ Need ModExp      (\ size -> [Req size ModMul
+--                                       ,Req size ModSq
+--                                       ,Req size Barretts])
+--         , Need ModSq       (\ size -> [Req (size * 2) Div
+--                                       ,Req size Barretts
+--                                       ,Req size Square])
+--         , Need ModMul      (\ size -> [Req size Mul
+--                                       ,Req size Barretts
+--                                       ,Req size (Convert (size * 2))
+--                                       ,Req (size * 2) Div])
+--         , Need Barretts    (\ size -> [Req (size + 64) BaseOps
+--                                       ,Req size (Convert (size + 64))
+--                                       ,Req (size + 64) (Convert ((size * 2) + 64))
+--                                       ,Req size (Convert ((size * 2) + 64))
+--                                       ,Req ((size * 2) + 64) Add
+--                                       ,Req ((size * 2) + 64) Sub
+--                                       ,Req (size + 64) Mul
+--                                       ,Req (size * 2) (Convert ((size * 2) + 64))
+--                                       ,Req ((size * 2) + 64) Shifts
+--                                       ,Req ((size * 2) + 128) Shifts
+--                                       ,Req ((size * 2) + 64) Div
+--                                       ,Req (size + 64) (Convert (size * 2))
+--                                       ,Req (size + 64) (Convert ((size * 2) + 128))
+--                                       ,Req ((size * 2) + 64)
+--                                            (Convert ((size * 2) + 128))
+--                                       ])
+--         , Need Div         (\ size -> [Req size (Convert (size * 2))
+--                                       ,Req 192 BaseOps
+--                                       ,Req 384 BaseOps
+--                                       ,Req 192 Mul
+--                                       ,Req size Mul
+--                                       ,Req size Shifts
+--                                       ,Req (size * 2) Sub
+--                                       ])
+--         , Need Mul         (\ size -> [Req (size * 2) BaseOps])
+--         , Need Sub         (\ size -> [Req size Add])
+--         , Need Add         (\ size -> [Req (size + 64) BaseOps
+--                                       ,Req size (Convert (size + 64))])
+--         , Need ModInv      (\ size -> [Req size SignedBase,
+--                                        Req size EGCD])
+--         , Need EGCD        (\ size -> [Req size BaseOps,
+--                                        Req (size + 64) SignedBase,
+--                                        Req size (SigConvert (size + 64)),
+--                                        Req (size + 64) SignedShift,
+--                                        Req (size + 64) SignedAdd,
+--                                        Req (size + 64) SignedSub,
+--                                        Req (size + 64) SignedCmp
+--                                        ])
+--         , Need SignedShift (\ size -> [Req size Shifts, Req size Add])
+--         , Need SignedAdd   (\ size -> [Req size Sub,
+--                                        Req (size + 64) Add,
+--                                        Req (size + 64) SignedBase,
+--                                        Req size (SigConvert (size + 64))
+--                                        ])
+--         , Need SignedSub   (\ size -> [Req (size + 64) SignedBase,
+--                                        Req size (SigConvert (size + 64)),
+--                                        Req size Sub
+--                                        ])
+--         , Need RSA         (\ size -> [Req size ModExp, Req size ModInv,
+--                                        Req (size `div` 2) Sub,
+--                                        Req (size `div` 2) Mul])
+--         ]
 
 newRequirements :: Requirement -> [Requirement]
 newRequirements (Req size op) = concatMap go needs ++ [Req size BaseOps]
@@ -109,11 +214,11 @@ newRequirements (Req size op) = concatMap go needs ++ [Req size BaseOps]
   go (Need op2 generator) | op == op2 = generator size
                           | otherwise = []
 
-bitSizes :: [Int]
+rsaSizes :: [Int]
-bitSizes =  [192,256,384,512,576,1024,2048,3072,4096,7680,8192,15360]
+rsaSizes =  [512,1024,2048,3072,4096,8192,15360]
 
 baseRequirements :: [Requirement]
-baseRequirements = concatMap (\ x -> [Req x ModExp, Req x ModInv]) bitSizes
+baseRequirements = concatMap (\ x -> [Req x RSA]) rsaSizes
 
 requirements :: [Requirement]
 requirements = go baseRequirements
@@ -216,9 +321,9 @@ generateInvocs = do
        generateTestBlock hndl "modmul"         ModMul   True  4000  []
        generateTestBlock hndl "modexp"         ModExp   True  512   []
        generateTestBlock hndl "square"         Square   True  4000  [(* 2)]
-       generateTestBlock hndl "barrett_modsq"  Barretts True  4000  [(+ 64)]
+       generateTestBlock hndl "barrett_modsq"  ModSq    True  4000  [(+ 64)]
-       generateTestBlock hndl "barrett_modmul" Barretts True  4000  [(+ 64)]
+       generateTestBlock hndl "barrett_modmul" ModMul   True  4000  [(+ 64)]
-       generateTestBlock hndl "barrett_modexp" Barretts True  1024  [(+ 64)]
+       generateTestBlock hndl "barrett_modexp" ModExp   True  1024  [(+ 64)]
        hPutStrLn hndl "}"
   withFile "src/signed/invoc.rs" WriteMode $ \ hndl ->
     do forM_ requirements $ \ (Req size oper) ->

src/signed/invoc.rs

@@ -1,31 +1,3 @@
-signed_impls!(I192, U192);
-conversion_impls!(I192, U192, I256, U256);
-egcd_impls!(I256, U192, I192);
-modinv_impls!(U192, I256, U256);
-add_impls!(I256, I320, U320);
-signed_impls!(I256, U256);
-cmp_impls!(I256);
-shift_impls!(I256, U256);
-subtraction_impls!(I256, I320, U320);
-conversion_impls!(I256, U256, I320, U320);
-egcd_impls!(I320, U256, I256);
-modinv_impls!(U256, I320, U320);
-add_impls!(I320, I384, U384);
-signed_impls!(I320, U320);
-cmp_impls!(I320);
-shift_impls!(I320, U320);
-subtraction_impls!(I320, I384, U384);
-conversion_impls!(I320, U320, I384, U384);
-signed_impls!(I384, U384);
-conversion_impls!(I384, U384, I448, U448);
-egcd_impls!(I448, U384, I384);
-modinv_impls!(U384, I448, U448);
-add_impls!(I448, I512, U512);
-signed_impls!(I448, U448);
-cmp_impls!(I448);
-shift_impls!(I448, U448);
-subtraction_impls!(I448, I512, U512);
-conversion_impls!(I448, U448, I512, U512);
 signed_impls!(I512, U512);
 conversion_impls!(I512, U512, I576, U576);
 egcd_impls!(I576, U512, I512);
@@ -36,15 +8,7 @@ cmp_impls!(I576);
 shift_impls!(I576, U576);
 subtraction_impls!(I576, I640, U640);
 conversion_impls!(I576, U576, I640, U640);
-egcd_impls!(I640, U576, I576);
-modinv_impls!(U576, I640, U640);
-add_impls!(I640, I704, U704);
 signed_impls!(I640, U640);
-cmp_impls!(I640);
-shift_impls!(I640, U640);
-subtraction_impls!(I640, I704, U704);
-conversion_impls!(I640, U640, I704, U704);
-signed_impls!(I704, U704);
 signed_impls!(I1024, U1024);
 conversion_impls!(I1024, U1024, I1088, U1088);
 egcd_impls!(I1088, U1024, I1024);
@@ -89,17 +53,6 @@ shift_impls!(I4160, U4160);
 subtraction_impls!(I4160, I4224, U4224);
 conversion_impls!(I4160, U4160, I4224, U4224);
 signed_impls!(I4224, U4224);
-signed_impls!(I7680, U7680);
-conversion_impls!(I7680, U7680, I7744, U7744);
-egcd_impls!(I7744, U7680, I7680);
-modinv_impls!(U7680, I7744, U7744);
-add_impls!(I7744, I7808, U7808);
-signed_impls!(I7744, U7744);
-cmp_impls!(I7744);
-shift_impls!(I7744, U7744);
-subtraction_impls!(I7744, I7808, U7808);
-conversion_impls!(I7744, U7744, I7808, U7808);
-signed_impls!(I7808, U7808);
 signed_impls!(I8192, U8192);
 conversion_impls!(I8192, U8192, I8256, U8256);
 egcd_impls!(I8256, U8192, I8192);
@@ -130,16 +83,11 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_sigadd_tests!(I256, U256, i256, I320, U320);
-    generate_sigadd_tests!(I320, U320, i320, I384, U384);
-    generate_sigadd_tests!(I448, U448, i448, I512, U512);
     generate_sigadd_tests!(I576, U576, i576, I640, U640);
-    generate_sigadd_tests!(I640, U640, i640, I704, U704);
     generate_sigadd_tests!(I1088, U1088, i1088, I1152, U1152);
     generate_sigadd_tests!(I2112, U2112, i2112, I2176, U2176);
     generate_sigadd_tests!(I3136, U3136, i3136, I3200, U3200);
     generate_sigadd_tests!(I4160, U4160, i4160, I4224, U4224);
-    generate_sigadd_tests!(I7744, U7744, i7744, I7808, U7808);
     generate_sigadd_tests!(I8256, U8256, i8256, I8320, U8320);
     generate_sigadd_tests!(I15424, U15424, i15424, I15488, U15488);
   }
@@ -147,16 +95,11 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_sigsub_tests!(I256, U256, i256, I320, U320);
-    generate_sigsub_tests!(I320, U320, i320, I384, U384);
-    generate_sigsub_tests!(I448, U448, i448, I512, U512);
     generate_sigsub_tests!(I576, U576, i576, I640, U640);
-    generate_sigsub_tests!(I640, U640, i640, I704, U704);
     generate_sigsub_tests!(I1088, U1088, i1088, I1152, U1152);
     generate_sigsub_tests!(I2112, U2112, i2112, I2176, U2176);
     generate_sigsub_tests!(I3136, U3136, i3136, I3200, U3200);
     generate_sigsub_tests!(I4160, U4160, i4160, I4224, U4224);
-    generate_sigsub_tests!(I7744, U7744, i7744, I7808, U7808);
     generate_sigsub_tests!(I8256, U8256, i8256, I8320, U8320);
     generate_sigsub_tests!(I15424, U15424, i15424, I15488, U15488);
   }
@@ -164,15 +107,9 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_signed_tests!(I192, U192, i192);
-    generate_signed_tests!(I256, U256, i256);
-    generate_signed_tests!(I320, U320, i320);
-    generate_signed_tests!(I384, U384, i384);
-    generate_signed_tests!(I448, U448, i448);
     generate_signed_tests!(I512, U512, i512);
     generate_signed_tests!(I576, U576, i576);
     generate_signed_tests!(I640, U640, i640);
-    generate_signed_tests!(I704, U704, i704);
     generate_signed_tests!(I1024, U1024, i1024);
     generate_signed_tests!(I1088, U1088, i1088);
     generate_signed_tests!(I1152, U1152, i1152);
@@ -185,9 +122,6 @@ mod tests {
     generate_signed_tests!(I4096, U4096, i4096);
     generate_signed_tests!(I4160, U4160, i4160);
     generate_signed_tests!(I4224, U4224, i4224);
-    generate_signed_tests!(I7680, U7680, i7680);
-    generate_signed_tests!(I7744, U7744, i7744);
-    generate_signed_tests!(I7808, U7808, i7808);
     generate_signed_tests!(I8192, U8192, i8192);
     generate_signed_tests!(I8256, U8256, i8256);
     generate_signed_tests!(I8320, U8320, i8320);
@@ -196,15 +130,9 @@ mod tests {
     generate_signed_tests!(I15488, U15488, i15488);
   }
   mod sigconversion {
-    generate_sigconversion_tests!(I192, U192, i192);
-    generate_sigconversion_tests!(I256, U256, i256);
-    generate_sigconversion_tests!(I320, U320, i320);
-    generate_sigconversion_tests!(I384, U384, i384);
-    generate_sigconversion_tests!(I448, U448, i448);
     generate_sigconversion_tests!(I512, U512, i512);
     generate_sigconversion_tests!(I576, U576, i576);
     generate_sigconversion_tests!(I640, U640, i640);
-    generate_sigconversion_tests!(I704, U704, i704);
     generate_sigconversion_tests!(I1024, U1024, i1024);
     generate_sigconversion_tests!(I1088, U1088, i1088);
     generate_sigconversion_tests!(I1152, U1152, i1152);
@@ -217,9 +145,6 @@ mod tests {
     generate_sigconversion_tests!(I4096, U4096, i4096);
     generate_sigconversion_tests!(I4160, U4160, i4160);
     generate_sigconversion_tests!(I4224, U4224, i4224);
-    generate_sigconversion_tests!(I7680, U7680, i7680);
-    generate_sigconversion_tests!(I7744, U7744, i7744);
-    generate_sigconversion_tests!(I7808, U7808, i7808);
     generate_sigconversion_tests!(I8192, U8192, i8192);
     generate_sigconversion_tests!(I8256, U8256, i8256);
     generate_sigconversion_tests!(I8320, U8320, i8320);
@@ -231,16 +156,11 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_sigcmp_tests!(I256, U256, i256);
-    generate_sigcmp_tests!(I320, U320, i320);
-    generate_sigcmp_tests!(I448, U448, i448);
     generate_sigcmp_tests!(I576, U576, i576);
-    generate_sigcmp_tests!(I640, U640, i640);
     generate_sigcmp_tests!(I1088, U1088, i1088);
     generate_sigcmp_tests!(I2112, U2112, i2112);
     generate_sigcmp_tests!(I3136, U3136, i3136);
     generate_sigcmp_tests!(I4160, U4160, i4160);
-    generate_sigcmp_tests!(I7744, U7744, i7744);
     generate_sigcmp_tests!(I8256, U8256, i8256);
     generate_sigcmp_tests!(I15424, U15424, i15424);
   }
@@ -248,16 +168,11 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_sigshiftl_tests!(I256, U256, i256);
-    generate_sigshiftl_tests!(I320, U320, i320);
-    generate_sigshiftl_tests!(I448, U448, i448);
     generate_sigshiftl_tests!(I576, U576, i576);
-    generate_sigshiftl_tests!(I640, U640, i640);
     generate_sigshiftl_tests!(I1088, U1088, i1088);
     generate_sigshiftl_tests!(I2112, U2112, i2112);
     generate_sigshiftl_tests!(I3136, U3136, i3136);
     generate_sigshiftl_tests!(I4160, U4160, i4160);
-    generate_sigshiftl_tests!(I7744, U7744, i7744);
     generate_sigshiftl_tests!(I8256, U8256, i8256);
     generate_sigshiftl_tests!(I15424, U15424, i15424);
   }
@@ -265,16 +180,11 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_sigshiftr_tests!(I256, U256, i256);
-    generate_sigshiftr_tests!(I320, U320, i320);
-    generate_sigshiftr_tests!(I448, U448, i448);
     generate_sigshiftr_tests!(I576, U576, i576);
-    generate_sigshiftr_tests!(I640, U640, i640);
     generate_sigshiftr_tests!(I1088, U1088, i1088);
     generate_sigshiftr_tests!(I2112, U2112, i2112);
     generate_sigshiftr_tests!(I3136, U3136, i3136);
     generate_sigshiftr_tests!(I4160, U4160, i4160);
-    generate_sigshiftr_tests!(I7744, U7744, i7744);
     generate_sigshiftr_tests!(I8256, U8256, i8256);
     generate_sigshiftr_tests!(I15424, U15424, i15424);
   }
@@ -282,16 +192,11 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_egcd_tests!(I192, U192, i192, I256, U256);
-    generate_egcd_tests!(I256, U256, i256, I320, U320);
-    generate_egcd_tests!(I384, U384, i384, I448, U448);
     generate_egcd_tests!(I512, U512, i512, I576, U576);
-    generate_egcd_tests!(I576, U576, i576, I640, U640);
     generate_egcd_tests!(ignore I1024, U1024, i1024, I1088, U1088);
     generate_egcd_tests!(ignore I2048, U2048, i2048, I2112, U2112);
     generate_egcd_tests!(ignore I3072, U3072, i3072, I3136, U3136);
     generate_egcd_tests!(ignore I4096, U4096, i4096, I4160, U4160);
-    generate_egcd_tests!(ignore I7680, U7680, i7680, I7744, U7744);
     generate_egcd_tests!(ignore I8192, U8192, i8192, I8256, U8256);
     generate_egcd_tests!(ignore I15360, U15360, i15360, I15424, U15424);
   }
@@ -299,16 +204,11 @@ mod tests {
     use super::super::*;
     use testing::run_test;
 
-    generate_modinv_tests!(I192, U192, i192);
-    generate_modinv_tests!(I256, U256, i256);
-    generate_modinv_tests!(I384, U384, i384);
     generate_modinv_tests!(I512, U512, i512);
-    generate_modinv_tests!(I576, U576, i576);
     generate_modinv_tests!(I1024, U1024, i1024);
     generate_modinv_tests!(ignore I2048, U2048, i2048);
     generate_modinv_tests!(ignore I3072, U3072, i3072);
     generate_modinv_tests!(ignore I4096, U4096, i4096);
-    generate_modinv_tests!(ignore I7680, U7680, i7680);
     generate_modinv_tests!(ignore I8192, U8192, i8192);
     generate_modinv_tests!(ignore I15360, U15360, i15360);
   }