Update some of the technical debt.

Looks like we were also computing our test cases in a slightly sketchy
way, and just testing that we failed in exactly the same way. We do, but
now we generate better test data.

.gitignore

@@ -22,4 +22,5 @@ Cargo.lock
 FlameGraph
 *.user_stacks
 **/.ghc.environment.*
-tests/rsa/dist*
+
+test.ed25519

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "cryptonum"]
+	path = cryptonum
+	url = https://github.com/acw/cryptonum.git

.travis.yml

@@ -0,0 +1,9 @@
+language: rust
+rust:
+  - stable
+  - beta
+  - nightly
+matrix:
+  allow_failures:
+    - nightly
+  fast_finish: true

Cargo.toml

@@ -9,13 +9,14 @@ license-file = "LICENSE"
 repository = "https://github.com/acw/simple_crypto"
 
 [dependencies]
-byteorder   = "^1.2.7"
+base64      = "^0.10.1"
+byteorder   = "^1.3.1"
 chrono      = "^0.4.6"
-cryptonum   = { path = "../cryptonum" }
+cryptonum   = { path = "cryptonum" }
 digest      = "^0.8.0"
 hmac        = "^0.7.0"
 num         = "^0.2.0"
-rand        = "^0.6.0"
+rand        = "^0.6.5"
 sha-1       = "^0.8.1"
 sha2        = "^0.8.0"
 simple_asn1 = "^0.2.0"

TECHNICAL_DEBT

@@ -1,5 +1,3 @@
-- Build RSA test cases from Haskell examples
-- Build DSA test cases from Haskell examples
 - Add negative test cases (RSA, DSA, ECDSA)
 - Make Point::double_scalar_mult() not truly awful
 - Use std::Default instead of the bespoke default() in Point?
@@ -7,4 +5,7 @@
 - Run clippy on this stuff
 - De-macro. Surely some of this stuff could be turned into trait invocations?
 - Test cases for key generation
-- Better, timing-resistant ECC point math
+- Better, timing-resistant ECC point math
+- Make the x.509 library not terrible
+- Ability to generate a SSH public key line / file
+- Extend SSH examples with public key reading/writing

src/dsa/mod.rs

@@ -1,7 +1,44 @@
+//! If you want to use this module to generate keys, which you really
+//! really shouldn't, there are two ways to do so, depending on whether
+//! you've previously agreed on a set of DSA parameters for this key
+//! pair. If you haven't, you can generate the parameters using a good
+//! random number generator.
+//! 
+//! ```rust
+//! extern crate sha2;
+//! 
+//! use simple_crypto::dsa::{DSAKeyPair,DSAParameters,L2048N256};
+//! use sha2::Sha224;
+//! 
+//! // Generate a set of DSA parameters, assuming you don't have
+//! // them already
+//! let mut rng = rand::rngs::OsRng::new().unwrap();
+//! let params = L2048N256::generate(&mut rng);
+//! 
+//! // Given those parameters, you can generate a key pair like so:
+//! let kp = DSAKeyPair::<L2048N256>::generate(&params, &mut rng);
+//! // Keeping in mind that you can re-use the parameters across multiple
+//! // keys, and that their secrecy isn't paramout for the security of the
+//! // algorithm.
+//!
+//! // Now that you have this key pair, you can sign and verify messages
+//! // using it. For example, to sign the vector [0,1,2,3,4] with SHA224
+//! // and then verify that signature, we would write: 
+//! let msg = vec![0,1,2,3,4];
+//! let sig = kp.private.sign::<Sha224>(&msg);
+//! assert!( kp.public.verify::<Sha224>(&msg, &sig) );
+//! ```
+
+
 mod errors;
 mod params;
 mod private;
 mod public;
+/// Support for RFC6979 signing, which provides a secure way to generate
+/// signatures without the use of a random number generator. This is used
+/// in DSA signing as well as in ECDSA signing, but appears here because
+/// ... well, because it was written for DSA first, both historically
+/// (I think) and by me.
 pub mod rfc6979;
 #[cfg(test)]
 mod tests;
@@ -13,27 +50,41 @@ pub use self::public::*;
 use cryptonum::unsigned::*;
 use rand::Rng;
 use rand::distributions::Standard;
+use super::KeyPair;
 
-pub struct DSAKeyPair<P,L,N>
+/// A DSA key pair, for use in signing and signature verification. Note
+/// that you probably shouldn't be using DSA any more; ECDSA or ED25519
+/// are probably better options.
+/// 
+/// DSA key pairs are parameterized by their DSA parameters, so that
+/// you can't accidentally use them in the wrong place.
+pub struct DSAKeyPair<P: DSAParameters>
 {
-    pub private: DSAPrivKey<P,N>,
+    pub private: DSAPrivateKey<P>,
-    pub public: DSAPubKey<P,L>
+    pub public: DSAPublicKey<P>
 }
 
-pub trait DSAKeyGeneration
+impl<P: DSAParameters> KeyPair for DSAKeyPair<P>
 {
-    type Params;
+    type Private = DSAPrivateKey<P>;
+    type Public = DSAPublicKey<P>;
 
-    fn generate<G: Rng>(params: &Self::Params, rng: &mut G) -> Self;
+    fn new(public: DSAPublicKey<P>, private: DSAPrivateKey<P>) -> DSAKeyPair<P>
+    {
+        DSAKeyPair{ private, public }
+    }
 }
 
 macro_rules! generate_dsa_pair {
     ($ptype: ident, $ltype: ident, $ntype: ident, $nbig: ident) => {
-        impl DSAKeyGeneration for DSAKeyPair<$ptype,$ltype,$ntype>
+        impl DSAKeyPair<$ptype>
         {
-            type Params = $ptype;
+            /// Generate a DSA key pair using the given parameters and random
-
+            /// number generator. Please make sure that the RNG you're using
-            fn generate<G: Rng>(params: &$ptype, rng: &mut G) -> Self
+            /// is suitable for key generators (look for the term "cryptographic"
+            /// or "crypto strong" in its documentation, or see if it matches
+            /// any of the NIST-suggested RNG algorithms).
+            pub fn generate<G: Rng>(params: &$ptype, rng: &mut G) -> Self
             {
                 // 1. N = len(q); L = len(p);
                 let n = $ptype::n_size();
@@ -45,7 +96,7 @@ macro_rules! generate_dsa_pair {
                 //    strength of requested_security_strength or more. If an ERROR
                 //    indication is returned, then return an ERROR indication,
                 //    Invalid_x, and Invalid_y.
-                let returned_bits: Vec<u8> = rng.sample_iter(&Standard).take(n + 8).collect();
+                let returned_bits: Vec<u8> = rng.sample_iter(&Standard).take( (n + 64) / 8 ).collect();
                 // 5. Convert returned_bits to the (non-negative) integer c.
                 let c = $nbig::from_bytes(&returned_bits);
                 // 6. x = (c mod (q-1)) + 1.
@@ -55,8 +106,8 @@ macro_rules! generate_dsa_pair {
                 // 7. y = g^x mod p
                 let y = params.g.modexp(&$ltype::from(&x), &params.p);
                 // 8. Return SUCCESS, x, and y.
-                let private = DSAPrivKey::new(params.clone(), x);
+                let private = DSAPrivateKey::<$ptype>::new(params.clone(), x);
-                let public  = DSAPubKey::new(params.clone(), y);
+                let public  = DSAPublicKey::<$ptype>::new(params.clone(), y);
                 DSAKeyPair { private, public }
             }
         }

src/dsa/params.rs

@@ -6,16 +6,30 @@ use simple_asn1::{ToASN1,ASN1Block,ASN1Class,ASN1EncodeErr};
 use rand::Rng;
 use utils::TranslateNums;
 
+/// A trait that describes what a set of DSA parameters must support in
+/// order to be used by the rest of the system.
 pub trait DSAParameters : ToASN1
 {
+    /// The fixed-width, unsigned type of values in L.
     type L;
+    /// The fixed-width, unsigned type of values in N.
     type N;
 
+    /// Given a `p`, `g`, and `q`, generate a new structure that includes
+    /// this information. Optionally, do any cross-checks needed.
     fn new(p: Self::L, g: Self::L, q: Self::N) -> Self;
+    /// Generate a new set of DSA parameters given the provided random
+    /// number generator. Just as with key generation, this should be a
+    /// cryptographically-strong random number generator. If it's not,
+    /// you may be writing compromisable code.
     fn generate<G: Rng>(rng: &mut G) -> Self;
+    /// Return the size of values of N in bits.
     fn n_size() -> usize;
+    /// Return the size of values of L in bits.
     fn l_size() -> usize;
-
+    /// Return the size of `q` in this particular instance of the parameters.
+    /// (Should be the same as `n_size()`, and the default implementation
+    /// simply uses `n_size(), but included for convenience)
     fn n_bits(&self) -> usize {
         Self::n_size()
     }
@@ -23,7 +37,8 @@ pub trait DSAParameters : ToASN1
 
 macro_rules! generate_parameters {
     ($name: ident, $ltype: ident, $ntype: ident, $l: expr, $n: expr) => {
-        #[derive(Clone)]
+        /// DSA parameters to the given L and N, with the values given in bits.
+        #[derive(Clone,PartialEq)]
         pub struct $name {
             pub p: $ltype,
             pub g: $ltype,
@@ -71,7 +86,7 @@ macro_rules! generate_parameters {
 
         impl $name
         {
-            fn generate_primes<G: Rng>(rng: &mut G) -> ($ltype,$ntype,U256,usize)
+            pub fn generate_primes<G: Rng>(rng: &mut G) -> ($ltype,$ntype,U256,usize)
             {
                 // This is A.1.1.2 from FIPS 186-4, with seedlen hardcoded to 256
                 // (since that's guaranteed to be >= N), and with the hash
@@ -91,7 +106,7 @@ macro_rules! generate_parameters {
                 // 2. If (seedlen < N), then return INVALID.
                 // [This is always true.]
                 //
-                // 3. n = L/outlen – 1. 
+                // 3. n = L/outlen – 1.
                 let n = ((L + 255) / 256) - 1;
                 // 4. b = L – 1 – (n ∗ outlen). 
                 let b = L - 1 - (n * outlen);
@@ -105,10 +120,9 @@ macro_rules! generate_parameters {
                     #[allow(non_snake_case)]
                     let U = $ntype::from_bytes(&ubytes);
                     // 7. q = 2^(N–1) + U + 1 – (U mod 2).
-                    let ulow = if U.is_even() { 0 } else { 1 };
+                    let highbit = $ntype::from(1u64) << (N - 1);
-                    let mut q = $ntype::from(1u64) << (N - 1);
+                    let lowbit  = $ntype::from(1u64);
-                    q += U;
+                    let q = U | highbit | lowbit;
-                    q += $ntype::from(1u64 + ulow);
                     // 8. Test whether or not q is prime as specified in Appendix C.3. 
                     let q_is_prime = q.probably_prime(rng, 40);
                     // 9. If q is not a prime, then go to step 5. 
@@ -126,7 +140,7 @@ macro_rules! generate_parameters {
                         for j in 0..n {
                             let val = &domain_parameter_seed + U256::from(offset + j);
                             let bytes = hash(&val, 32);
-                            assert_eq!(seedlen, bytes.len());
+                            assert_eq!(seedlen, bytes.len() * 8);
                             V.push(bytes);
                         }
                         // 11.2 W = V_0 + ( V_1 ∗ 2^outlen) + ... + ( V_(n–1) ∗ 2^(n –1) ∗ outlen) + ((V_n mod 2^b) ∗ 2^(n ∗ outlen).

src/dsa/private.rs

@@ -5,49 +5,33 @@ use dsa::params::*;
 use dsa::rfc6979::*;
 use hmac::{Hmac,Mac};
 
-pub trait DSAPrivateKey {
+/// A DSA private key, parameterized by its DSA parameters (so that you don't
-    type Params;
+/// accidentally pass the wrong key to the wrong routine).
-    type L;
+pub struct DSAPrivateKey<Params: DSAParameters>
-    type N;
-
-    /// Generate a new private key using the given DSA parameters and private
-    /// key value.
-    fn new(params: Self::Params, x: Self::N) -> Self;
-    /// Generate a DSA signature for the given message, using the appropriate
-    /// hash included in the type invocation.
-    fn sign<Hash>(&self, m: &[u8]) -> DSASignature<Self::N>
-     where
-      Hash: BlockInput + Clone + Default + Digest + FixedOutput + Input + Reset,
-      Hmac<Hash>: Mac;
-}
-
-pub struct DSAPrivKey<Params,N>
 {
     pub(crate) params: Params,
-    pub(crate) x: N
+    pub(crate) x: Params::N
 }
 
+/// A generic DSA private key enum, which masks which kind of DSA key (1024,
+/// 2048 with the small `n`, 2048 with the normal `n`, or 3072) you're using.
 pub enum DSAPrivate {
-    DSA1024Private(DSAPrivKey<L1024N160,U192>),
+    DSA1024Private(DSAPrivateKey<L1024N160>),
-    DSA2048SmallPrivate(DSAPrivKey<L2048N224,U256>),
+    DSA2048SmallPrivate(DSAPrivateKey<L2048N224>),
-    DSA2048Private(DSAPrivKey<L2048N256,U256>),
+    DSA2048Private(DSAPrivateKey<L2048N256>),
-    DSA3072Private(DSAPrivKey<L3072N256,U256>)
+    DSA3072Private(DSAPrivateKey<L3072N256>)
 }
 
 macro_rules! privkey_impls {
     ($ptype: ident, $ltype: ident, $ntype: ident, $big: ident, $bigger: ident, $biggest: ident) => {
-       impl DSAPrivateKey for DSAPrivKey<$ptype,$ntype>
+       impl DSAPrivateKey<$ptype>
        {
-           type Params = $ptype;
+           pub fn new(params: $ptype, x: $ntype) -> DSAPrivateKey<$ptype>
-           type L = $ltype;
-           type N = $ntype;
-
-           fn new(params: $ptype, x: $ntype) -> DSAPrivKey<$ptype,$ntype>
            {
-               DSAPrivKey{ params, x }
+               DSAPrivateKey{ params, x }
            }
 
-           fn sign<Hash>(&self, m: &[u8]) -> DSASignature<$ntype>
+           pub fn sign<Hash>(&self, m: &[u8]) -> DSASignature<$ntype>
              where
               Hash: BlockInput + Clone + Default + Digest + FixedOutput + Input + Reset,
               Hmac<Hash>: Mac
@@ -116,4 +100,64 @@ macro_rules! privkey_impls {
 privkey_impls!(L1024N160, U1024, U192, U384, U448, U896);
 privkey_impls!(L2048N224, U2048, U256, U512, U576, U1152);
 privkey_impls!(L2048N256, U2048, U256, U512, U576, U1152);
-privkey_impls!(L3072N256, U3072, U256, U512, U576, U1152);
+privkey_impls!(L3072N256, U3072, U256, U512, U576, U1152);
+
+macro_rules! generate_tests {
+    ( $( ($mod: ident, $params: ident, $lt: ident, $nt: ident) ),* ) => {
+        $(
+        #[cfg(test)]
+        #[allow(non_snake_case)]
+        mod $mod {
+            use cryptonum::unsigned::Decoder;
+            use super::*;
+            use testing::run_test;
+            use sha2::{Sha224,Sha256,Sha384,Sha512};
+
+            #[test]
+            fn verify() {
+                let fname = format!("testdata/dsa/sign{}.test", stringify!($params));
+                run_test(fname.to_string(), 9, |case| {
+                    let (neg0, pbytes) = case.get("p").unwrap();
+                    let (neg1, qbytes) = case.get("q").unwrap();
+                    let (neg2, gbytes) = case.get("g").unwrap();
+                    let (neg3, _bytes) = case.get("y").unwrap();
+                    let (neg4, xbytes) = case.get("x").unwrap();
+                    let (neg5, mbytes) = case.get("m").unwrap();
+                    let (neg6, hbytes) = case.get("h").unwrap();
+                    let (neg7, rbytes) = case.get("r").unwrap();
+                    let (neg8, sbytes) = case.get("s").unwrap();
+
+                    assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 &&
+                            !neg5 && !neg6 && !neg7 && !neg8);
+                    let p = $lt::from_bytes(pbytes);
+                    let q = $nt::from_bytes(qbytes);
+                    let g = $lt::from_bytes(gbytes);
+                    let x = $nt::from_bytes(xbytes);
+                    //let y = $lt::from_bytes(ybytes);
+                    let h = usize::from($nt::from_bytes(hbytes));
+                    let r = $nt::from_bytes(rbytes);
+                    let s = $nt::from_bytes(sbytes);
+
+                    let params = $params::new(p,g,q);
+                    let private = DSAPrivateKey::<$params>::new(params, x);
+                    let sig = match h {
+                        224 => private.sign::<Sha224>(mbytes),
+                        256 => private.sign::<Sha256>(mbytes),
+                        384 => private.sign::<Sha384>(mbytes),
+                        512 => private.sign::<Sha512>(mbytes),
+                        _   => panic!("Unexpected hash {}", h)
+                    };
+                    assert_eq!(r, sig.r);
+                    assert_eq!(s, sig.s);
+                });
+            }
+        }
+        )*
+    }
+}
+
+generate_tests!( (DSA1024N160, L1024N160, U1024, U192),
+                 (DSA2048N224, L2048N224, U2048, U256),
+                 (DSA2048N256, L2048N256, U2048, U256),
+                 (DSA3072N256, L3072N256, U3072, U256)
+               );

src/dsa/public.rs

@@ -7,45 +7,32 @@ use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,ToASN1};
 use std::cmp::min;
 use utils::TranslateNums;
 
-pub trait DSAPublicKey {
+/// A DSA public key, parameterized by its DSA parameters (so that you don't
-    type Params : DSAParameters;
+/// accidentally pass the wrong thing to the wrong function).
-    type L;
+pub struct DSAPublicKey<Params: DSAParameters> {
-    type N;
-
-    /// Generate a new public key given the parameters and public value.
-    fn new(params: Self::Params, y: Self::L) -> Self;
-    /// Verify the given signature against the given message, using the
-    /// appropriate hash function.
-    fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<Self::N>) -> bool
-      where Hash: Digest;
-}
-
-pub struct DSAPubKey<Params,L> {
     pub(crate) params: Params,
-    pub(crate) y: L
+    pub(crate) y: Params::L
 }
 
+/// An enumeration that hides exactly which parameters you're using. Use at
+/// your own risk, as the types won't save you.
 pub enum DSAPublic {
-    DSAPublicL1024N160(DSAPubKey<L1024N160,U1024>),
+    DSAPublicL1024N160(DSAPublicKey<L1024N160>),
-    DSAPublicL2048N224(DSAPubKey<L2048N224,U2048>),
+    DSAPublicL2048N224(DSAPublicKey<L2048N224>),
-    DSAPublicL2048N256(DSAPubKey<L2048N256,U2048>),
+    DSAPublicL2048N256(DSAPublicKey<L2048N256>),
-    DSAPublicL3072N256(DSAPubKey<L3072N256,U3072>)
+    DSAPublicL3072N256(DSAPublicKey<L3072N256>)
 }
 
 macro_rules! pubkey_impls {
     ($ptype: ident, $ltype: ident, $ntype: ident, $dbl: ident, $bdbl: ident) => {
-        impl DSAPublicKey for DSAPubKey<$ptype,$ltype>
+        impl DSAPublicKey<$ptype>
         {
-            type Params = $ptype;
+            pub fn new(params: $ptype, y: $ltype) -> DSAPublicKey<$ptype>
-            type L = $ltype;
-            type N = $ntype;
-
-            fn new(params: $ptype, y: $ltype) -> DSAPubKey<$ptype,$ltype>
             {
-                DSAPubKey{ params, y }
+                DSAPublicKey{ params, y }
             }
 
-            fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<$ntype>) -> bool
+            pub fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<$ntype>) -> bool
              where Hash: Digest
             {
                 if sig.r >= self.params.q {
@@ -80,7 +67,7 @@ macro_rules! pubkey_impls {
             }
         }
 
-        impl ToASN1 for DSAPubKey<$ptype,$ltype> {
+        impl ToASN1 for DSAPublicKey<$ptype> {
             type Error = ASN1EncodeErr;
 
             fn to_asn1_class(&self, c: ASN1Class)
@@ -97,4 +84,63 @@ macro_rules! pubkey_impls {
 pubkey_impls!(L1024N160, U1024, U192, U384, U2048);
 pubkey_impls!(L2048N224, U2048, U256, U512, U4096);
 pubkey_impls!(L2048N256, U2048, U256, U512, U4096);
-pubkey_impls!(L3072N256, U3072, U256, U512, U6144);
+pubkey_impls!(L3072N256, U3072, U256, U512, U6144);
+
+macro_rules! generate_tests {
+    ( $( ($mod: ident, $params: ident, $lt: ident, $nt: ident) ),* ) => {
+        $(
+        #[cfg(test)]
+        #[allow(non_snake_case)]
+        mod $mod {
+            use cryptonum::unsigned::Decoder;
+            use super::*;
+            use testing::run_test;
+            use sha2::{Sha224,Sha256,Sha384,Sha512};
+
+            #[test]
+            fn verify() {
+                let fname = format!("testdata/dsa/sign{}.test", stringify!($params));
+                run_test(fname.to_string(), 9, |case| {
+                    let (neg0, pbytes) = case.get("p").unwrap();
+                    let (neg1, qbytes) = case.get("q").unwrap();
+                    let (neg2, gbytes) = case.get("g").unwrap();
+                    let (neg3, ybytes) = case.get("y").unwrap();
+                    let (neg4, _bytes) = case.get("x").unwrap();
+                    let (neg5, mbytes) = case.get("m").unwrap();
+                    let (neg6, hbytes) = case.get("h").unwrap();
+                    let (neg7, rbytes) = case.get("r").unwrap();
+                    let (neg8, sbytes) = case.get("s").unwrap();
+
+                    assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 &&
+                            !neg5 && !neg6 && !neg7 && !neg8);
+                    let p = $lt::from_bytes(pbytes);
+                    let q = $nt::from_bytes(qbytes);
+                    let g = $lt::from_bytes(gbytes);
+                    //let x = $lt::from_bytes(xbytes);
+                    let y = $lt::from_bytes(ybytes);
+                    let h = usize::from($nt::from_bytes(hbytes));
+                    let r = $nt::from_bytes(rbytes);
+                    let s = $nt::from_bytes(sbytes);
+
+                    let params = $params::new(p,g,q);
+                    let public = DSAPublicKey::<$params>::new(params, y);
+                    let sig = DSASignature::<$nt>::new(r, s);
+                    match h {
+                        224 => assert!(public.verify::<Sha224>(mbytes, &sig)),
+                        256 => assert!(public.verify::<Sha256>(mbytes, &sig)),
+                        384 => assert!(public.verify::<Sha384>(mbytes, &sig)),
+                        512 => assert!(public.verify::<Sha512>(mbytes, &sig)),
+                        _   => panic!("Unexpected hash {}", h)
+                    }
+                });
+            }
+        }
+        )*
+    }
+}
+
+generate_tests!( (DSA1024N160, L1024N160, U1024, U192),
+                 (DSA2048N224, L2048N224, U2048, U256),
+                 (DSA2048N256, L2048N256, U2048, U256),
+                 (DSA3072N256, L3072N256, U3072, U256)
+               );

src/dsa/tests.rs

@@ -4,8 +4,8 @@ use sha1::Sha1;
 use sha2::{Sha224,Sha256,Sha384,Sha512};
 use simple_asn1::{der_decode,der_encode};
 use dsa::params::{DSAParameters,L1024N160,L2048N256};
-use dsa::private::{DSAPrivateKey,DSAPrivKey};
+use dsa::private::DSAPrivateKey;
-use dsa::public::{DSAPublicKey,DSAPubKey};
+use dsa::public::DSAPublicKey;
 use dsa::rfc6979::KIterator;
 
 macro_rules! run_rfc6979_test {
@@ -99,8 +99,8 @@ fn appendix_a21() {
     let params = L1024N160::new(p, g, q);
     let x = U192::from_bytes(&xbytes);
     let y = U1024::from_bytes(&ybytes);
-    let private = DSAPrivKey::new(params.clone(), x);
+    let private = DSAPrivateKey::<L1024N160>::new(params.clone(), x);
-    let public = DSAPubKey::<L1024N160,U1024>::new(params.clone(), y);
+    let public = DSAPublicKey::<L1024N160>::new(params.clone(), y);
     //
     let sample: [u8; 6] = [115, 97, 109, 112, 108, 101]; // "sample", ASCII
     let test:   [u8; 4] = [116, 101, 115, 116]; // "test", ASCII
@@ -359,8 +359,8 @@ fn appendix_a22() {
     let params = L2048N256::new(p, g, q);
     let x = U256::from_bytes(&xbytes);
     let y = U2048::from_bytes(&ybytes);
-    let private = DSAPrivKey::<L2048N256,U256>::new(params.clone(), x);
+    let private = DSAPrivateKey::<L2048N256>::new(params.clone(), x);
-    let public = DSAPubKey::<L2048N256,U2048>::new(params.clone(), y);
+    let public = DSAPublicKey::<L2048N256>::new(params.clone(), y);
     //
     let sample: [u8; 6] = [115, 97, 109, 112, 108, 101]; // "sample", ASCII
     let test:   [u8; 4] = [116, 101, 115, 116]; // "test", ASCII

src/ecdsa/curve.rs

@@ -1,28 +1,54 @@
 use cryptonum::signed::{I192,I256,I384,I576};
 use cryptonum::unsigned::{Decoder};
 use cryptonum::unsigned::{U192,U256,U384,U576};
+use ecdsa::point::Point;
+use std::fmt::Debug;
 
+/// Elliptic curves must implement this trait in order to work with the rest
+/// of the ECDSA system. I've included instances for the core NIST curves
+/// used in most systems, but this could be extended without issues.
+/// (Eventually the curves defined here should actually be extended in
+/// interesting ways to make the math faster, but we haven't gotten there
+/// yet.)
 #[allow(non_snake_case)]
 pub trait EllipticCurve {
+    /// The unsigned numeric type that fits constants for this curve.
     type Unsigned : Clone;
-    type Signed : Clone;
+    /// The signed numeric type that fits constants for this curve.
+    type Signed : Clone + Debug + PartialEq;
+    /// The type of a point on the curve
+    type Point;
 
+    /// The size of the curve in bits.
     fn size() -> usize;
+    /// The `p` value for the curve.
     fn p() -> Self::Unsigned;
+    /// The `p` value for the curve.
     fn n() -> Self::Unsigned;
+    /// The seed value for the curve.
     fn SEED() -> Self::Unsigned;
+    /// The `c` value for the curve.
     fn c() -> Self::Unsigned;
+    /// The `a` value for the curve.
     fn a() -> Self::Unsigned;
+    /// The `b` value for the curve.
     fn b() -> Self::Unsigned;
+    /// The `x` coordinate of the base point for the curve.
     fn Gx() -> Self::Signed;
+    /// The `y` coordinate of the base point for the curve.
     fn Gy() -> Self::Signed;
+    /// Generate a point for the curve given the provided values.
+    fn new_point(x: Self::Unsigned, y: Self::Unsigned) -> Self::Point;
 }
 
-pub enum P192 {}
+/// NIST curve P-192 (FIPS 186-4, page 101-102), a.k.a. secp192r1 from RFC5480
+#[derive(Debug,PartialEq)]
+pub struct P192 {}
 
 impl EllipticCurve for P192 {
     type Unsigned = U192;
     type Signed = I192;
+    type Point = Point<P192>;
 
     fn size() -> usize {
         192
@@ -59,13 +85,20 @@ impl EllipticCurve for P192 {
     fn Gy() -> I192 {
         I192::from(U192::from([0x73f977a11e794811, 0x631011ed6b24cdd5, 0x07192b95ffc8da78]))
     }
+
+    fn new_point(x: Self::Unsigned, y: Self::Unsigned) -> Self::Point {
+        Point::<P192>{ x: I192::from(x), y: I192::from(y) }
+    }
 }
 
-pub enum P224 {}
+/// NIST curve P-224 (FIPS 186-4, page 102), a.k.a. secp224r1 from RFC5480
+#[derive(Debug,PartialEq)]
+pub struct P224 {}
 
 impl EllipticCurve for P224 {
     type Unsigned = U256;
     type Signed = I256;
+    type Point = Point<P224>;
 
     fn size() -> usize {
         224
@@ -141,13 +174,20 @@ impl EllipticCurve for P224 {
                 0x85, 0x00, 0x7e, 0x34
         ]))
     }
+
+    fn new_point(x: Self::Unsigned, y: Self::Unsigned) -> Self::Point {
+        Point::<P224>{ x: I256::from(x), y: I256::from(y) }
+    }
 }
 
-pub enum P256 {}
+/// NIST curve P-256 (FIPS 186-4, page 102-103), a.k.a. secp256r1 from RFC5480
+#[derive(Debug,PartialEq)]
+pub struct P256 {}
 
 impl EllipticCurve for P256 {
     type Signed = I256;
     type Unsigned = U256;
+    type Point = Point<P256>;
 
     fn size() -> usize {
         256
@@ -224,13 +264,20 @@ impl EllipticCurve for P256 {
                 0xcb, 0xb6, 0x40, 0x68, 0x37, 0xbf, 0x51, 0xf5
         ]))
     }
+
+    fn new_point(x: Self::Unsigned, y: Self::Unsigned) -> Self::Point {
+        Point::<P256>{ x: I256::from(x), y: I256::from(y) }
+    }
 }
 
-pub enum P384 {}
+/// NIST curve P-384 (FIPS 186-4, page 103-104), a.k.a. secp384r1 from RFC5480
+#[derive(Debug,PartialEq)]
+pub struct P384 {}
 
 impl EllipticCurve for P384 {
     type Signed = I384;
     type Unsigned = U384;
+    type Point = Point<P384>;
 
     fn size() -> usize {
         384
@@ -320,13 +367,20 @@ impl EllipticCurve for P384 {
                 0x7a, 0x43, 0x1d, 0x7c, 0x90, 0xea, 0x0e, 0x5f
         ]))
     }
+
+    fn new_point(x: Self::Unsigned, y: Self::Unsigned) -> Self::Point {
+        Point::<P384>{ x: I384::from(x), y: I384::from(y) }
+    }
 }
 
-pub enum P521 {}
+/// NIST curve P-521 (FIPS 186-4, page 104), a.k.a. secp521r1 from RFC5480
+#[derive(Debug,PartialEq)]
+pub struct P521 {}
 
 impl EllipticCurve for P521 {
     type Signed = I576;
     type Unsigned = U576;
+    type Point = Point<P521>;
 
     fn size() -> usize {
         521
@@ -437,4 +491,8 @@ impl EllipticCurve for P521 {
                 0x66, 0x50
         ]))
     }
+
+    fn new_point(x: Self::Unsigned, y: Self::Unsigned) -> Self::Point {
+        Point::<P521>{ x: I576::from(x), y: I576::from(y) }
+    }
 }

src/ecdsa/mod.rs

@@ -1,27 +1,95 @@
-pub mod curve;
+//! The generation and use of ECDSA keys is pretty straightforward, compared
-pub mod point;
+//! to DSA and RSA. You should be able to find what you want to do in the
-pub mod private;
+//! following code snippet, as an example:
-pub mod public;
+//!
+//! ```rust
+//! extern crate sha2;
+//! 
+//! use simple_crypto::ecdsa::{ECDSAKeyPair,P384};
+//! use sha2::Sha256;
+//! 
+//! // Generate a new ECDSA key for curve P384 (this is a good choice, by
+//! // the way, if you're wondering which curve to use).
+//! let mut rng = rand::rngs::OsRng::new().unwrap();
+//! let kp = ECDSAKeyPair::<P384>::generate(&mut rng);
+//! 
+//! // Now that you have this key pair, you can sign and verify messages
+//! // using it. For example, to sign the vector [0,1,2,3,4] with SHA256
+//! // and then verify that signature, we would write: 
+//! let msg = vec![0,1,2,3,4];
+//! let sig = kp.private.sign::<Sha256>(&msg);
+//! assert!( kp.public.verify::<Sha256>(&msg, &sig) );
+//! ```
+
+mod curve;
+pub(crate) mod point;
+mod private;
+mod public;
 
 use cryptonum::signed::{I192,I256,I384,I576};
 use cryptonum::unsigned::{CryptoNum,Decoder};
 use cryptonum::unsigned::{U192,U256,U384,U576};
 use rand::Rng;
 use rand::distributions::Standard;
-use self::curve::{EllipticCurve,P192,P224,P256,P384,P521};
+pub use self::curve::{EllipticCurve,P192,P224,P256,P384,P521};
 use self::point::{ECCPoint,Point};
-pub use self::private::{ECCPrivateKey,ECCPrivate};
+pub use self::private::{ECDSAPrivate,ECCPrivateKey};
-pub use self::public::{ECCPublicKey,ECDSAPublic,ECCPubKey};
+pub use self::public::{ECDSAPublic,ECCPublicKey};
 pub use self::public::{ECDSADecodeErr,ECDSAEncodeErr};
+use super::KeyPair;
 
-pub trait ECDSAKeyPair<Public,Private> {
+/// An ECDSA key pair for the given curve.
-    fn generate<G: Rng>(g: &mut G) -> (Public, Private);
+pub struct ECDSAKeyPair<Curve: EllipticCurve> {
+    pub public: ECCPublicKey<Curve>,
+    pub private: ECCPrivateKey<Curve>
+}
+
+/// A generic ECDSA key pair that implements one of our known curves, for cases
+/// when you're not sure which one you're going to have.
+pub enum ECDSAPair {
+    P192(ECCPublicKey<P192>,ECCPrivateKey<P192>),
+    P224(ECCPublicKey<P224>,ECCPrivateKey<P224>),
+    P256(ECCPublicKey<P256>,ECCPrivateKey<P256>),
+    P384(ECCPublicKey<P384>,ECCPrivateKey<P384>),
+    P521(ECCPublicKey<P521>,ECCPrivateKey<P521>),
+}
+
+impl KeyPair for ECDSAPair {
+    type Public = ECDSAPublic;
+    type Private = ECDSAPrivate;
+
+    fn new(pu: ECDSAPublic, pr: ECDSAPrivate) -> ECDSAPair
+    {
+        match (pu, pr) {
+            (ECDSAPublic::P192(pbl),ECDSAPrivate::P192(prv)) => ECDSAPair::P192(pbl,prv),
+            (ECDSAPublic::P224(pbl),ECDSAPrivate::P224(prv)) => ECDSAPair::P224(pbl,prv),
+            (ECDSAPublic::P256(pbl),ECDSAPrivate::P256(prv)) => ECDSAPair::P256(pbl,prv),
+            (ECDSAPublic::P384(pbl),ECDSAPrivate::P384(prv)) => ECDSAPair::P384(pbl,prv),
+            (ECDSAPublic::P521(pbl),ECDSAPrivate::P521(prv)) => ECDSAPair::P521(pbl,prv),
+            _ =>
+                panic!("Non-matching public/private pairs in ECDSAPair::new()")
+        } 
+    }
 }
 
 macro_rules! generate_impl {
     ($curve: ident, $un: ident, $si: ident) => {
-        impl ECDSAKeyPair<ECCPubKey<$curve>,ECCPrivate<$curve>> for $curve {
+        impl KeyPair for ECDSAKeyPair<$curve> {
-            fn generate<G: Rng>(rng: &mut G) -> (ECCPubKey<$curve>, ECCPrivate<$curve>)
+            type Public = ECCPublicKey<$curve>;
+            type Private = ECCPrivateKey<$curve>;
+
+            fn new(public: ECCPublicKey<$curve>, private: ECCPrivateKey<$curve>) -> ECDSAKeyPair<$curve>
+            {
+                ECDSAKeyPair{ public, private }
+            }
+        }
+
+        impl ECDSAKeyPair<$curve> {
+            /// Generate a fresh ECDSA key pair for this curve, given the
+            /// provided random number generator. THIS MUST BE A CRYPTO
+            /// STRONG RNG. If it's not, then you're going to generate weak
+            /// keys and the crypto gremlins will get you.
+            pub fn generate<G: Rng>(rng: &mut G) -> ECDSAKeyPair<$curve>
             {
                 loop {
                     let size = ($curve::size() + 7) / 8;
@@ -38,9 +106,10 @@ macro_rules! generate_impl {
 
                     let d = $si::from(&proposed_d);
                     let public_point = Point::<$curve>::default().scale(&d);
-                    let public = ECCPubKey::<$curve>::new(public_point);
+                    let public = ECCPublicKey::<$curve>::new(public_point);
-                    let private = ECCPrivate::<$curve>::new(proposed_d);
+                    let private = ECCPrivateKey::<$curve>::new(proposed_d);
-                    return (public, private);
+
+                    return ECDSAKeyPair{ public, private };
                 }
             }
         }

src/ecdsa/point.rs

@@ -20,6 +20,7 @@ pub trait ECCPoint : Sized {
     }
 }
 
+#[derive(Debug,PartialEq)]
 pub struct Point<T: EllipticCurve>
 {
     pub x: T::Signed,
@@ -147,6 +148,137 @@ point_impl!(P256, I256, I512,  U512,  I576,  U576);
 point_impl!(P384, I384, I768,  U768,  I832,  U832);
 point_impl!(P521, I576, I1152, U1152, I1216, U1216);
 
+#[cfg(test)]
+macro_rules! negate_test_body
+{
+    ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
+        let fname = build_test_path("ecc/negate",stringify!($curve));
+        run_test(fname.to_string(), 4, |case| {
+            let (negx, xbytes) = case.get("x").unwrap();
+            let (negy, ybytes) = case.get("y").unwrap();
+            let (nega, abytes) = case.get("a").unwrap();
+            let (negb, bbytes) = case.get("b").unwrap();
+
+            let x = $stype::new(*negx, $utype::from_bytes(xbytes));
+            let y = $stype::new(*negy, $utype::from_bytes(ybytes));
+            let a = $stype::new(*nega, $utype::from_bytes(abytes));
+            let b = $stype::new(*negb, $utype::from_bytes(bbytes));
+            let point = Point::<$curve>{ x, y };
+            let dbl = point.negate();
+            assert_eq!(a, dbl.x, "x equivalence");
+            assert_eq!(b, dbl.y, "y equivalence");
+        });
+    }
+}
+
+#[cfg(test)]
+macro_rules! double_test_body
+{
+    ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
+        let fname = build_test_path("ecc/double",stringify!($curve));
+        run_test(fname.to_string(), 4, |case| {
+            let (negx, xbytes) = case.get("x").unwrap();
+            let (negy, ybytes) = case.get("y").unwrap();
+            let (nega, abytes) = case.get("a").unwrap();
+            let (negb, bbytes) = case.get("b").unwrap();
+
+            let x = $stype::new(*negx, $utype::from_bytes(xbytes));
+            let y = $stype::new(*negy, $utype::from_bytes(ybytes));
+            let a = $stype::new(*nega, $utype::from_bytes(abytes));
+            let b = $stype::new(*negb, $utype::from_bytes(bbytes));
+            let point = Point::<$curve>{ x, y };
+            let dbl = point.double();
+            assert_eq!(a, dbl.x, "x equivalence");
+            assert_eq!(b, dbl.y, "y equivalence");
+        });
+    }
+}
+
+#[cfg(test)]
+macro_rules! add_test_body
+{
+    ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
+        let fname = build_test_path("ecc/add",stringify!($curve));
+        run_test(fname.to_string(), 6, move |case| {
+            let (negx, xbytes) = case.get("x").unwrap();
+            let (negy, ybytes) = case.get("y").unwrap();
+            let (negu, ubytes) = case.get("u").unwrap();
+            let (negv, vbytes) = case.get("v").unwrap();
+            let (nega, abytes) = case.get("a").unwrap();
+            let (negb, bbytes) = case.get("b").unwrap();
+
+            let x = $stype::new(*negx, $utype::from_bytes(xbytes));
+            let y = $stype::new(*negy, $utype::from_bytes(ybytes));
+            let u = $stype::new(*negu, $utype::from_bytes(ubytes));
+            let v = $stype::new(*negv, $utype::from_bytes(vbytes));
+            let a = $stype::new(*nega, $utype::from_bytes(abytes));
+            let b = $stype::new(*negb, $utype::from_bytes(bbytes));
+            let point1 = Point::<$curve>{ x: x, y: y };
+            let point2 = Point::<$curve>{ x: u, y: v };
+            let res = point1.add(&point2);
+            assert_eq!(a, res.x, "x equivalence");
+            assert_eq!(b, res.y, "y equivalence");
+        });
+    }
+}
+
+#[cfg(test)]
+macro_rules! scale_test_body
+{
+    ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
+        let fname = build_test_path("ecc/scale",stringify!($curve));
+        run_test(fname.to_string(), 5, |case| {
+            let (negx, xbytes) = case.get("x").unwrap();
+            let (negy, ybytes) = case.get("y").unwrap();
+            let (negk, kbytes) = case.get("k").unwrap();
+            let (nega, abytes) = case.get("a").unwrap();
+            let (negb, bbytes) = case.get("b").unwrap();
+
+            let x = $stype::new(*negx, $utype::from_bytes(xbytes));
+            let y = $stype::new(*negy, $utype::from_bytes(ybytes));
+            let k = $stype::new(*negk, $utype::from_bytes(kbytes));
+            let a = $stype::new(*nega, $utype::from_bytes(abytes));
+            let b = $stype::new(*negb, $utype::from_bytes(bbytes));
+            let point = Point::<$curve>{ x: x, y: y };
+            let res   = point.scale(&k);
+            assert_eq!(a, res.x, "x equivalence");
+            assert_eq!(b, res.y, "y equivalence");
+        });
+    }
+}
+
+#[cfg(test)]
+macro_rules! add_scale2_test_body
+{
+    ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
+        let fname = build_test_path("ecc/add_scale2",stringify!($curve));
+        run_test(fname.to_string(), 8, |case| {
+            let (negx, xbytes) = case.get("x").unwrap();
+            let (negy, ybytes) = case.get("y").unwrap();
+            let (negp, pbytes) = case.get("p").unwrap();
+            let (negq, qbytes) = case.get("q").unwrap();
+            let (negn, nbytes) = case.get("n").unwrap();
+            let (negm, mbytes) = case.get("m").unwrap();
+            let (negr, rbytes) = case.get("r").unwrap();
+            let (negs, sbytes) = case.get("s").unwrap();
+
+            let x = $stype::new(*negx, $utype::from_bytes(xbytes));
+            let y = $stype::new(*negy, $utype::from_bytes(ybytes));
+            let p = $stype::new(*negp, $utype::from_bytes(pbytes));
+            let q = $stype::new(*negq, $utype::from_bytes(qbytes));
+            let n = $stype::new(*negn, $utype::from_bytes(nbytes));
+            let m = $stype::new(*negm, $utype::from_bytes(mbytes));
+            let r = $stype::new(*negr, $utype::from_bytes(rbytes));
+            let s = $stype::new(*negs, $utype::from_bytes(sbytes));
+            let p1  = Point::<$curve>{ x: x, y: y };
+            let p2  = Point::<$curve>{ x: p, y: q };
+            let res = Point::<$curve>::double_scalar_mult(&n, &p1, &m, &p2);
+            assert_eq!(r, res.x, "x equivalence");
+            assert_eq!(s, res.y, "y equivalence");
+        });
+    }
+}
+
 macro_rules! point_tests
 {
     ($curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
@@ -156,138 +288,42 @@ macro_rules! point_tests
             use testing::*;
 
             #[test]
-            fn negate() {
+            fn negate() { negate_test_body!($curve, $lcurve, $stype, $utype); }
-                let fname = build_test_path("ecc/negate",stringify!($curve));
+            #[test]
-                run_test(fname.to_string(), 4, |case| {
+            fn double() { double_test_body!($curve, $lcurve, $stype, $utype); }
-                    let (negx, xbytes) = case.get("x").unwrap();
+            #[test]
-                    let (negy, ybytes) = case.get("y").unwrap();
+            fn add() { add_test_body!($curve, $lcurve, $stype, $utype); }
-                    let (nega, abytes) = case.get("a").unwrap();
+            #[test]
-                    let (negb, bbytes) = case.get("b").unwrap();
+            fn scale() { scale_test_body!($curve, $lcurve, $stype, $utype); }
-
+            #[ignore]
-                    let x = $stype::new(*negx, $utype::from_bytes(xbytes));
+            #[test]
-                    let y = $stype::new(*negy, $utype::from_bytes(ybytes));
+            fn add_scale2() { add_scale2_test_body!($curve, $lcurve, $stype, $utype); }
-                    let a = $stype::new(*nega, $utype::from_bytes(abytes));
+        }
-                    let b = $stype::new(*negb, $utype::from_bytes(bbytes));
+    };
-                    let point = Point::<$curve>{ x, y };
+    (ignore_expensive $curve: ident, $lcurve: ident, $stype: ident, $utype: ident) => {
-                    let dbl = point.negate();
+        #[cfg(test)]
-                    assert_eq!(a, dbl.x, "x equivalence");
+        mod $lcurve {
-                    assert_eq!(b, dbl.y, "y equivalence");
+            use super::*;
-                });
+            use testing::*;
-            }
 
             #[test]
-            fn double() {
+            fn negate() { negate_test_body!($curve, $lcurve, $stype, $utype); }
-                let fname = build_test_path("ecc/double",stringify!($curve));
-                run_test(fname.to_string(), 4, |case| {
-                    let (negx, xbytes) = case.get("x").unwrap();
-                    let (negy, ybytes) = case.get("y").unwrap();
-                    let (nega, abytes) = case.get("a").unwrap();
-                    let (negb, bbytes) = case.get("b").unwrap();
-
-                    let x = $stype::new(*negx, $utype::from_bytes(xbytes));
-                    let y = $stype::new(*negy, $utype::from_bytes(ybytes));
-                    let a = $stype::new(*nega, $utype::from_bytes(abytes));
-                    let b = $stype::new(*negb, $utype::from_bytes(bbytes));
-                    let point = Point::<$curve>{ x, y };
-                    let dbl = point.double();
-                    assert_eq!(a, dbl.x, "x equivalence");
-                    assert_eq!(b, dbl.y, "y equivalence");
-                });
-            }
-
             #[test]
-            fn add() {
+            fn double() { double_test_body!($curve, $lcurve, $stype, $utype); }
-                let fname = build_test_path("ecc/add",stringify!($curve));
-                run_test(fname.to_string(), 6, move |case| {
-                    let (negx, xbytes) = case.get("x").unwrap();
-                    let (negy, ybytes) = case.get("y").unwrap();
-                    let (negu, ubytes) = case.get("u").unwrap();
-                    let (negv, vbytes) = case.get("v").unwrap();
-                    let (nega, abytes) = case.get("a").unwrap();
-                    let (negb, bbytes) = case.get("b").unwrap();
-
-                    let x = $stype::new(*negx, $utype::from_bytes(xbytes));
-                    let y = $stype::new(*negy, $utype::from_bytes(ybytes));
-                    let u = $stype::new(*negu, $utype::from_bytes(ubytes));
-                    let v = $stype::new(*negv, $utype::from_bytes(vbytes));
-                    let a = $stype::new(*nega, $utype::from_bytes(abytes));
-                    let b = $stype::new(*negb, $utype::from_bytes(bbytes));
-                    let point1 = Point::<$curve>{ x: x, y: y };
-                    let point2 = Point::<$curve>{ x: u, y: v };
-                    let res = point1.add(&point2);
-                    assert_eq!(a, res.x, "x equivalence");
-                    assert_eq!(b, res.y, "y equivalence");
-                });
-            }
-
             #[test]
-            fn scale() {
+            fn add() { add_test_body!($curve, $lcurve, $stype, $utype); }
-                let fname = build_test_path("ecc/scale",stringify!($curve));
+            #[ignore]
-                run_test(fname.to_string(), 5, |case| {
+            #[test]
-                    let (negx, xbytes) = case.get("x").unwrap();
+            fn scale() { scale_test_body!($curve, $lcurve, $stype, $utype); }
-                    let (negy, ybytes) = case.get("y").unwrap();
+            #[ignore]
-                    let (negk, kbytes) = case.get("k").unwrap();
+            #[test]
-                    let (nega, abytes) = case.get("a").unwrap();
+            fn add_scale2() { add_scale2_test_body!($curve, $lcurve, $stype, $utype); }
-                    let (negb, bbytes) = case.get("b").unwrap();
-
-                    let x = $stype::new(*negx, $utype::from_bytes(xbytes));
-                    let y = $stype::new(*negy, $utype::from_bytes(ybytes));
-                    let k = $stype::new(*negk, $utype::from_bytes(kbytes));
-                    let a = $stype::new(*nega, $utype::from_bytes(abytes));
-                    let b = $stype::new(*negb, $utype::from_bytes(bbytes));
-                    let point = Point::<$curve>{ x: x, y: y };
-                    let res   = point.scale(&k);
-                    assert_eq!(a, res.x, "x equivalence");
-                    assert_eq!(b, res.y, "y equivalence");
-                });
-            }
-
-             #[test]
-            fn add_scale2() {
-                let fname = build_test_path("ecc/add_scale2",stringify!($curve));
-                run_test(fname.to_string(), 8, |case| {
-                    println!("-----------------------------------------------");
-                    let (negx, xbytes) = case.get("x").unwrap();
-                    let (negy, ybytes) = case.get("y").unwrap();
-                    let (negp, pbytes) = case.get("p").unwrap();
-                    let (negq, qbytes) = case.get("q").unwrap();
-                    let (negn, nbytes) = case.get("n").unwrap();
-                    let (negm, mbytes) = case.get("m").unwrap();
-                    let (negr, rbytes) = case.get("r").unwrap();
-                    let (negs, sbytes) = case.get("s").unwrap();
-
-                    let x = $stype::new(*negx, $utype::from_bytes(xbytes));
-                    let y = $stype::new(*negy, $utype::from_bytes(ybytes));
-                    println!("x1: {:X}", x);
-                    println!("y1: {:X}", y);
-                    let p = $stype::new(*negp, $utype::from_bytes(pbytes));
-                    let q = $stype::new(*negq, $utype::from_bytes(qbytes));
-                    println!("x2: {:X}", p);
-                    println!("y2: {:X}", q);
-                    let n = $stype::new(*negn, $utype::from_bytes(nbytes));
-                    println!("n:  {:X}", n);
-                    let m = $stype::new(*negm, $utype::from_bytes(mbytes));
-                    println!("m:  {:X}", m);
-                    let r = $stype::new(*negr, $utype::from_bytes(rbytes));
-                    let s = $stype::new(*negs, $utype::from_bytes(sbytes));
-                    println!("rx: {:X}", r);
-                    println!("ry: {:X}", s);
-                    let p1  = Point::<$curve>{ x: x, y: y };
-                    let p2  = Point::<$curve>{ x: p, y: q };
-                    let res = Point::<$curve>::double_scalar_mult(&n, &p1, &m, &p2);
-                    println!("mx: {:X}", res.x);
-                    println!("my: {:X}", res.y);
-                    assert_eq!(r, res.x, "x equivalence");
-                    assert_eq!(s, res.y, "y equivalence");
-                });
-            }
-
         }
     }
 }
 
 point_tests!(P192, p192, I192, U192);
-point_tests!(P224, p224, I256, U256);
+point_tests!(ignore_expensive P224, p224, I256, U256);
-point_tests!(P256, p256, I256, U256);
+point_tests!(ignore_expensive P256, p256, I256, U256);
-point_tests!(P384, p384, I384, U384);
+point_tests!(ignore_expensive P384, p384, I384, U384);
-point_tests!(P521, p521, I576, U576);
+point_tests!(ignore_expensive P521, p521, I576, U576);

src/ecdsa/private.rs

@@ -5,34 +5,44 @@ use dsa::rfc6979::{DSASignature,KIterator,bits2int};
 use ecdsa::curve::{EllipticCurve,P192,P224,P256,P384,P521};
 use ecdsa::point::{ECCPoint,Point};
 use hmac::{Hmac,Mac};
+use std::fmt;
 
-pub struct ECCPrivate<Curve: EllipticCurve> {
+/// A private key for the given curve.
-    d: Curve::Unsigned
+#[derive(PartialEq)]
+pub struct ECCPrivateKey<Curve: EllipticCurve> {
+    pub(crate) d: Curve::Unsigned
 }
 
-pub trait ECCPrivateKey {
+impl<Curve: EllipticCurve> fmt::Debug for ECCPrivateKey<Curve> {
-    type Unsigned;
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(),fmt::Error>
+    {
+        f.write_str("<ECCPrivateKey>")
+    }
+}
 
-    fn new(d: Self::Unsigned) -> Self;
+/// A generic private key.
-    fn sign<Hash>(&self, m: &[u8]) -> DSASignature<Self::Unsigned>
+pub enum ECDSAPrivate {
-      where
+    P192(ECCPrivateKey<P192>),
-        Hash: BlockInput + Clone + Default + Digest + FixedOutput + Input + Reset,
+    P224(ECCPrivateKey<P224>),
-        Hmac<Hash>: Mac;
+    P256(ECCPrivateKey<P256>),
+    P384(ECCPrivateKey<P384>),
+    P521(ECCPrivateKey<P521>),
 }
 
 macro_rules! generate_privates
 {
     ($curve: ident, $base: ident, $sig: ident, $dbl: ident, $quad: ident) => {
-        impl ECCPrivateKey for ECCPrivate<$curve>
+        impl ECCPrivateKey<$curve>
         {
-            type Unsigned = $base;
+            /// Generate a new private key using the given private scalar.
-        
+            pub fn new(d: $base) -> ECCPrivateKey<$curve>
-            fn new(d: $base) -> ECCPrivate<$curve>
             {
-                ECCPrivate{ d }
+                ECCPrivateKey{ d }
             }
-        
+
-            fn sign<Hash>(&self, m: &[u8]) -> DSASignature<$base>
+            /// Sign the given message with the current key, using the hash provided
+            /// in the type.
+            pub fn sign<Hash>(&self, m: &[u8]) -> DSASignature<$base>
               where
                 Hash: BlockInput + Clone + Default + Digest + FixedOutput + Input + Reset,
                 Hmac<Hash>: Mac
@@ -112,47 +122,62 @@ use sha2::{Sha224,Sha256,Sha384,Sha512};
 #[cfg(test)]
 use testing::*;
 
+#[cfg(test)]
+macro_rules! sign_test_body
+{
+    ($name: ident, $curve: ident, $base: ident) => {
+        let fname = build_test_path("ecc/sign",stringify!($curve));
+        run_test(fname.to_string(), 9, |case| {
+            let (negd, dbytes) = case.get("d").unwrap();
+            let (negk, _bytes) = case.get("k").unwrap();
+            let (negx, xbytes) = case.get("x").unwrap();
+            let (negy, ybytes) = case.get("y").unwrap();
+            let (negm, mbytes) = case.get("m").unwrap();
+            let (negh, hbytes) = case.get("h").unwrap();
+            let (negr, rbytes) = case.get("r").unwrap();
+            let (negs, sbytes) = case.get("s").unwrap();
+
+            assert!(!negd && !negk && !negx && !negy &&
+                    !negm && !negh && !negr && !negs);
+            let d = $base::from_bytes(dbytes);
+            let _ = $base::from_bytes(xbytes);
+            let _ = $base::from_bytes(ybytes);
+            let h = $base::from_bytes(hbytes);
+            let r = $base::from_bytes(rbytes);
+            let s = $base::from_bytes(sbytes);
+
+            let private = ECCPrivateKey::<$curve>::new(d);
+            let sig = match usize::from(h) {
+                        224 => private.sign::<Sha224>(mbytes),
+                        256 => private.sign::<Sha256>(mbytes),
+                        384 => private.sign::<Sha384>(mbytes),
+                        512 => private.sign::<Sha512>(mbytes),
+                        x   => panic!("Unknown hash algorithm {}", x)
+            };
+            assert_eq!(r, sig.r, "r signature check");
+            assert_eq!(s, sig.s, "s signature check");
+        });
+    }
+}
+
 macro_rules! generate_tests {
     ($name: ident, $curve: ident, $base: ident) => {
         #[test]
         fn $name() {
-            let fname = build_test_path("ecc/sign",stringify!($curve));
+            sign_test_body!($name, $curve, $base);
-            run_test(fname.to_string(), 9, |case| {
+       }
-                let (negd, dbytes) = case.get("d").unwrap();
+    };
-                let (negk, _bytes) = case.get("k").unwrap();
+    (ignore $name: ident, $curve: ident, $base: ident) => {
-                let (negx, xbytes) = case.get("x").unwrap();
+        #[ignore]
-                let (negy, ybytes) = case.get("y").unwrap();
+        #[test]
-                let (negm, mbytes) = case.get("m").unwrap();
+        fn $name() {
-                let (negh, hbytes) = case.get("h").unwrap();
+            sign_test_body!($name, $curve, $base);
-                let (negr, rbytes) = case.get("r").unwrap();
+       }
-                let (negs, sbytes) = case.get("s").unwrap();
-
-                assert!(!negd && !negk && !negx && !negy &&
-                        !negm && !negh && !negr && !negs);
-                let d = $base::from_bytes(dbytes);
-                let _ = $base::from_bytes(xbytes);
-                let _ = $base::from_bytes(ybytes);
-                let h = $base::from_bytes(hbytes);
-                let r = $base::from_bytes(rbytes);
-                let s = $base::from_bytes(sbytes);
-
-                let private = ECCPrivate::<$curve>::new(d);
-                let sig = match usize::from(h) {
-                            224 => private.sign::<Sha224>(mbytes),
-                            256 => private.sign::<Sha256>(mbytes),
-                            384 => private.sign::<Sha384>(mbytes),
-                            512 => private.sign::<Sha512>(mbytes),
-                            x   => panic!("Unknown hash algorithm {}", x)
-                };
-                assert_eq!(r, sig.r, "r signature check");
-                assert_eq!(s, sig.s, "s signature check");
-            });
-        }
     };
 }
 
 generate_tests!(p192_sign, P192, U192);
-generate_tests!(p224_sign, P224, U256);
+generate_tests!(ignore p224_sign, P224, U256);
-generate_tests!(p256_sign, P256, U256);
+generate_tests!(ignore p256_sign, P256, U256);
-generate_tests!(p384_sign, P384, U384);
+generate_tests!(ignore p384_sign, P384, U384);
-generate_tests!(p521_sign, P521, U576);
+generate_tests!(ignore p521_sign, P521, U576);

src/ecdsa/public.rs

@@ -8,29 +8,24 @@ use hmac::{Hmac,Mac};
 use simple_asn1::{ASN1Block,ASN1Class,ASN1DecodeErr,ASN1EncodeErr,FromASN1,ToASN1};
 use std::cmp::min;
 
-pub struct ECCPubKey<Curve: EllipticCurve> {
+/// An ECDSA public key for the given curve.
-    q: Point<Curve>
+#[derive(Debug,PartialEq)]
+pub struct ECCPublicKey<Curve: EllipticCurve> {
+    pub(crate) q: Point<Curve>
 }
 
+/// A generic ECDSA public key, when you're not sure which curve you're
+/// going to get.
 pub enum ECDSAPublic {
-    ECCPublicP192(ECCPubKey<P192>),
+    P192(ECCPublicKey<P192>),
-    ECCPublicP224(ECCPubKey<P224>),
+    P224(ECCPublicKey<P224>),
-    ECCPublicP256(ECCPubKey<P256>),
+    P256(ECCPublicKey<P256>),
-    ECCPublicP384(ECCPubKey<P384>),
+    P384(ECCPublicKey<P384>),
-    ECCPublicP521(ECCPubKey<P521>),
+    P521(ECCPublicKey<P521>),
-}
-
-pub trait ECCPublicKey {
-    type Curve : EllipticCurve;
-    type Unsigned;
-
-    fn new(d: Point<Self::Curve>) -> Self;
-    fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<Self::Unsigned>) -> bool
-      where
-       Hash: BlockInput + Clone + Default + Digest + FixedOutput + Input + Reset,
-       Hmac<Hash>: Mac;
 }
 
+/// An error that can occur when encoding an ECDSA public key as an ASN.1
+/// object.
 pub enum ECDSAEncodeErr {
     ASN1EncodeErr(ASN1EncodeErr),
     XValueNegative, YValueNegative
@@ -42,6 +37,8 @@ impl From<ASN1EncodeErr> for ECDSAEncodeErr {
     }
 }
 
+/// An error that can occur when decoding an ECDSA public key from an
+/// ASN.1 blob.
 #[derive(Debug)]
 pub enum ECDSADecodeErr {
     ASN1DecodeErr(ASN1DecodeErr),
@@ -58,17 +55,17 @@ impl From<ASN1DecodeErr> for ECDSADecodeErr {
 
 macro_rules! public_impl {
     ($curve: ident, $un: ident, $si: ident) => {
-        impl ECCPublicKey for ECCPubKey<$curve>
+        impl ECCPublicKey<$curve>
         {
-            type Curve = $curve;
+            /// Generate a new public key object from the given public point.
-            type Unsigned = $un;
+            pub fn new(q: Point<$curve>) -> ECCPublicKey<$curve>
-
-            fn new(q: Point<$curve>) -> ECCPubKey<$curve>
             {
-                ECCPubKey{ q }
+                ECCPublicKey{ q }
             }
 
-            fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<Self::Unsigned>) -> bool
+            /// Returns true if the given message matches the given signature,
+            /// assuming the provided hash function.
+            pub fn verify<Hash>(&self, m: &[u8], sig: &DSASignature<$un>) -> bool
               where
                Hash: BlockInput + Clone + Default + Digest + FixedOutput + Input + Reset,
                Hmac<Hash>: Mac
@@ -103,7 +100,7 @@ macro_rules! public_impl {
             }
         }
 
-        impl ToASN1 for ECCPubKey<$curve> {
+        impl ToASN1 for ECCPublicKey<$curve> {
             type Error = ECDSAEncodeErr;
 
             fn to_asn1_class(&self, c: ASN1Class) -> Result<Vec<ASN1Block>,ECDSAEncodeErr>
@@ -136,10 +133,10 @@ macro_rules! public_impl {
             }
         }
 
-        impl FromASN1 for ECCPubKey<$curve> {
+        impl FromASN1 for ECCPublicKey<$curve> {
             type Error = ECDSADecodeErr;
 
-            fn from_asn1(bs: &[ASN1Block]) -> Result<(ECCPubKey<$curve>,&[ASN1Block]),ECDSADecodeErr>
+            fn from_asn1(bs: &[ASN1Block]) -> Result<(ECCPublicKey<$curve>,&[ASN1Block]),ECDSADecodeErr>
             {
                 let (x, rest) = bs.split_first().ok_or(ECDSADecodeErr::NoKeyFound)?;
                 if let ASN1Block::BitString(_, _, _, target) = x {
@@ -155,7 +152,7 @@ macro_rules! public_impl {
                     let x = $un::from_bytes(xbstr);
                     let y = $un::from_bytes(ybstr);
                     let point = Point::<$curve>{ x: $si::from(x), y: $si::from(y) };
-                    let res = ECCPubKey::<$curve>::new(point);
+                    let res = ECCPublicKey::<$curve>::new(point);
                     Ok((res, rest))
                 } else {
                     Err(ECDSADecodeErr::InvalidKeyFormat)
@@ -176,47 +173,62 @@ use sha2::{Sha224,Sha256,Sha384,Sha512};
 #[cfg(test)]
 use testing::*;
 
+#[cfg(test)]
+macro_rules! verify_test_body
+{
+    ($name: ident, $curve: ident, $un: ident, $si: ident) => {
+        let fname = build_test_path("ecc/sign",stringify!($curve));
+        run_test(fname.to_string(), 9, |case| {
+            let (negd, dbytes) = case.get("d").unwrap();
+            let (negk, _bytes) = case.get("k").unwrap();
+            let (negx, xbytes) = case.get("x").unwrap();
+            let (negy, ybytes) = case.get("y").unwrap();
+            let (negm, mbytes) = case.get("m").unwrap();
+            let (negh, hbytes) = case.get("h").unwrap();
+            let (negr, rbytes) = case.get("r").unwrap();
+            let (negs, sbytes) = case.get("s").unwrap();
+
+            assert!(!negd && !negk && !negx && !negy &&
+                    !negm && !negh && !negr && !negs);
+            let _ = $un::from_bytes(dbytes);
+            let x = $un::from_bytes(xbytes);
+            let y = $un::from_bytes(ybytes);
+            let h = $un::from_bytes(hbytes);
+            let r = $un::from_bytes(rbytes);
+            let s = $un::from_bytes(sbytes);
+
+            let point = Point::<$curve>{ x: $si::from(x), y: $si::from(y) };
+            let public = ECCPublicKey::<$curve>::new(point);
+            let sig = DSASignature::new(r, s);
+            match usize::from(h) {
+                224 => assert!(public.verify::<Sha224>(mbytes, &sig)),
+                256 => assert!(public.verify::<Sha256>(mbytes, &sig)),
+                384 => assert!(public.verify::<Sha384>(mbytes, &sig)),
+                512 => assert!(public.verify::<Sha512>(mbytes, &sig)),
+                x   => panic!("Unknown hash algorithm {}", x)
+            };
+        });
+    }
+}
+
 macro_rules! test_impl {
     ($name: ident, $curve: ident, $un: ident, $si: ident) => {
         #[test]
         fn $name() {
-            let fname = build_test_path("ecc/sign",stringify!($curve));
+            verify_test_body!($name, $curve, $un, $si);
-            run_test(fname.to_string(), 9, |case| {
+       }
-                let (negd, dbytes) = case.get("d").unwrap();
+    };
-                let (negk, _bytes) = case.get("k").unwrap();
+    (ignore $name: ident, $curve: ident, $un: ident, $si: ident) => {
-                let (negx, xbytes) = case.get("x").unwrap();
+        #[ignore]
-                let (negy, ybytes) = case.get("y").unwrap();
+        #[test]
-                let (negm, mbytes) = case.get("m").unwrap();
+        fn $name() {
-                let (negh, hbytes) = case.get("h").unwrap();
+            verify_test_body!($name, $curve, $un, $si);
-                let (negr, rbytes) = case.get("r").unwrap();
+       }
-                let (negs, sbytes) = case.get("s").unwrap();
-
-                assert!(!negd && !negk && !negx && !negy &&
-                        !negm && !negh && !negr && !negs);
-                let _ = $un::from_bytes(dbytes);
-                let x = $un::from_bytes(xbytes);
-                let y = $un::from_bytes(ybytes);
-                let h = $un::from_bytes(hbytes);
-                let r = $un::from_bytes(rbytes);
-                let s = $un::from_bytes(sbytes);
-
-                let point = Point::<$curve>{ x: $si::from(x), y: $si::from(y) };
-                let public = ECCPubKey::<$curve>::new(point);
-                let sig = DSASignature::new(r, s);
-                match usize::from(h) {
-                    224 => assert!(public.verify::<Sha224>(mbytes, &sig)),
-                    256 => assert!(public.verify::<Sha256>(mbytes, &sig)),
-                    384 => assert!(public.verify::<Sha384>(mbytes, &sig)),
-                    512 => assert!(public.verify::<Sha512>(mbytes, &sig)),
-                    x   => panic!("Unknown hash algorithm {}", x)
-                };
-            });
-        }
     };
 }
 
 test_impl!(p192,P192,U192,I192);
 test_impl!(p224,P224,U256,I256);
-test_impl!(p256,P256,U256,I256);
+test_impl!(ignore p256,P256,U256,I256);
-test_impl!(p384,P384,U384,I384);
+test_impl!(ignore p384,P384,U384,I384);
-test_impl!(p521,P521,U576,I576);
+test_impl!(ignore p521,P521,U576,I576);

src/ed25519/loads.rs

@@ -0,0 +1,33 @@
+#[cfg(test)]
+use cryptonum::unsigned::{Decoder,U192};
+#[cfg(test)]
+use testing::run_test;
+
+pub fn load3(x: &[u8]) -> u64
+{
+    (x[0] as u64) | ((x[1] as u64) << 8) | ((x[2] as u64) << 16)
+}
+
+pub fn load4(x: &[u8]) -> u64
+{
+    (x[0] as u64)         | ((x[1] as u64) << 8) |
+    ((x[2] as u64) << 16) | ((x[3] as u64) << 24)
+}
+
+#[cfg(test)]
+#[test]
+fn loads() {
+    let fname = "testdata/ed25519/load.test";
+    run_test(fname.to_string(), 3, |case| {
+        let (negx, xbytes) = case.get("x").unwrap();
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+
+        assert!(!negx && !nega && !negb);
+        let res3 = u64::from(U192::from_bytes(abytes));
+        let res4 = u64::from(U192::from_bytes(bbytes));
+        assert_eq!(res3, load3(&xbytes), "load3");
+        assert_eq!(res4, load4(&xbytes), "load4");
+    });
+}
+

src/ed25519/mod.rs

@@ -0,0 +1,268 @@
+//! The generation and use of ED25519 keys is the most straightforward
+//! of all the asymmetric crypto schemes, because you basically get no
+//! choices. There's just one key size, and you're going to use the
+//! built-in hash (which is a good one, if you were worried). So if
+//! you're not sure, this is a pretty good choice.
+//!
+//! ```rust
+//! use simple_crypto::ed25519::ED25519KeyPair;
+//! 
+//! // Generate a new ED25519 key
+//! let mut rng = rand::rngs::OsRng::new().unwrap();
+//! let kp = ED25519KeyPair::generate(&mut rng);
+//! 
+//! // Now that you have this key pair, you can sign and verify messages
+//! // using it. For example, to sign the vector [0,1,2,3,4] and then
+//! // verify that signature, we would write: 
+//! let msg = vec![0,1,2,3,4];
+//! let sig = kp.private.sign(&msg);
+//! assert!( kp.public.verify(&msg, &sig) );
+//! ```
+
+mod constants;
+mod fe;
+mod loads;
+mod point;
+mod scalars;
+
+use digest::Digest;
+use rand::Rng;
+use sha2::Sha512;
+use self::scalars::{curve25519_scalar_mask,x25519_sc_muladd,x25519_sc_reduce};
+use self::point::{Point,Point2};
+#[cfg(test)]
+use testing::run_test;
+#[cfg(test)]
+use std::collections::HashMap;
+use super::KeyPair;
+
+/// An ED25519 key pair
+#[derive(Debug,PartialEq)]
+pub struct ED25519KeyPair
+{
+    pub public: ED25519Public,
+    pub private: ED25519Private
+}
+
+impl KeyPair for ED25519KeyPair
+{
+    type Public = ED25519Public;
+    type Private = ED25519Private;
+
+    fn new(pbl: ED25519Public, prv: ED25519Private) -> ED25519KeyPair
+    {
+        ED25519KeyPair {
+            public: pbl,
+            private: prv
+        }
+    }
+}
+
+impl ED25519KeyPair
+{
+    /// Generate a random ED25519 key pair, using the given random number
+    /// generator. You really need to use a good, cryptographically-strong
+    /// RNG if you want good keys.
+    pub fn generate<G: Rng>(rng: &mut G) -> ED25519KeyPair
+    {
+        let mut seed = [0; 32];
+        rng.fill_bytes(&mut seed);
+        let private = ED25519Private::from_seed(&seed);
+        let public = ED25519Public::from(&private);
+        ED25519KeyPair::new(public, private)
+    }
+
+    /// Generate the ED25519 key pair defined by the given seed value.
+    /// This should be a block of 32 bytes.
+    pub fn from_seed(seed: &[u8]) -> ED25519KeyPair
+    {
+        let private = ED25519Private::from_seed(seed);
+        let public = ED25519Public::from(&private);
+        ED25519KeyPair{ public, private }
+    }
+}
+
+/// An ED25519 private key.
+#[derive(Debug,PartialEq)]
+pub struct ED25519Private
+{
+    seed:    [u8; 32],
+    private: [u8; 32],
+    prefix:  [u8; 32],
+    public:  [u8; 32]
+}
+
+impl ED25519Private {
+    /// Generate the ED25519 private key defined by the given 32 byte seed
+    /// value.
+    pub fn from_seed(seed: &[u8]) -> ED25519Private {
+        let mut result = ED25519Private {
+            seed: [0; 32],
+            private: [0; 32],
+            prefix: [0; 32],
+            public: [0; 32]
+        };
+        result.seed.copy_from_slice(seed);
+        let mut expanded = Sha512::digest(seed);
+        let (private, prefix) = expanded.split_at_mut(32);
+        result.private.copy_from_slice(private);
+        result.prefix.copy_from_slice(prefix);
+        curve25519_scalar_mask(&mut result.private);
+        let a = Point::scalarmult_base(&result.private);
+        result.public.copy_from_slice(&a.encode());
+        result
+    }
+
+    /// Sign the given message, returning the signature. Unlike most other
+    /// public/private schemes, you don't get a choice on the hash used to
+    /// compute this signature. (On the bright side, it's SHA2-512.)
+    pub fn sign(&self, msg: &[u8]) -> Vec<u8>
+    {
+        let mut signature_s = [0u8; 32];
+
+        let mut ctx = Sha512::new();
+        ctx.input(&self.prefix);
+        ctx.input(&msg);
+        let nonce = digest_scalar(ctx.result().as_slice());
+        let r = Point::scalarmult_base(&nonce);
+        let signature_r = r.encode();
+        let hram_digest = eddsa_digest(&signature_r, &self.public, &msg);
+        let hram = digest_scalar(&hram_digest);
+        x25519_sc_muladd(&mut signature_s, &hram, &self.private, &nonce);
+        let mut result = Vec::with_capacity(64);
+        result.extend_from_slice(&signature_r);
+        result.extend_from_slice(&signature_s);
+        result
+    }
+
+    /// Covert the given private key into its byte representation. This is
+    /// guaranteed to be exactly 32 bytes.
+    pub fn to_bytes(&self) -> Vec<u8>
+    {
+        self.seed.to_vec()
+    }
+}
+
+/// An ED25519 Public key
+#[derive(Debug,PartialEq)]
+pub struct ED25519Public
+{
+    bytes: [u8; 32],
+    point: Point
+}
+
+impl<'a> From<&'a ED25519Private> for ED25519Public
+{
+    fn from(x: &ED25519Private) -> ED25519Public
+    {
+        ED25519Public::new(&x.public).expect("Broke converting private ED25519 to public. (?!)")
+    }
+}
+
+/// The kinds of errors you can get when you try to generate a public key from,
+/// for example, an unknown block of bytes.
+#[derive(Debug)]
+pub enum ED25519PublicImportError
+{
+    WrongNumberOfBytes(usize),
+    InvalidPublicPoint
+}
+
+impl ED25519Public {
+    /// Generate an ED25519 public key given the provided (32 byte) bytes. This
+    /// can return errors if the value isn't a reasonable representation of an
+    /// ED25519 point.
+    pub fn new(bytes: &[u8]) -> Result<ED25519Public,ED25519PublicImportError>
+    {
+        if bytes.len() != 32 {
+            return Err(ED25519PublicImportError::WrongNumberOfBytes(bytes.len()));
+        }
+        match Point::from_bytes(&bytes) {
+            None =>
+                Err(ED25519PublicImportError::InvalidPublicPoint),
+            Some(a) => {
+                let mut res = ED25519Public{ bytes: [0; 32], point: a };
+                res.bytes.copy_from_slice(&bytes);
+                Ok(res)
+            }
+        }
+    }
+
+    /// Verify that the given signature matches the given message.
+    pub fn verify(&self, msg: &[u8], sig: &[u8]) -> bool
+    {
+        assert_eq!(sig.len(), 64);
+
+        let signature_r = &sig[..32];
+        let signature_s = &sig[32..];
+
+        if signature_s[31] & 0b11100000 != 0 {
+            return false;
+        }
+
+        let ainv = self.point.invert();
+        let h_digest = eddsa_digest(signature_r, &self.bytes, msg);
+        let h = digest_scalar(&h_digest);
+        let r = Point2::double_scalarmult_vartime(&h, &ainv, &signature_s);
+        let r_check = r.encode();
+        signature_r.to_vec() == r_check
+    }
+
+    /// Turn the ED25519 into its byte representation. This will always be a
+    /// 32 byte block.
+    pub fn to_bytes(&self) -> Vec<u8>
+    {
+        self.bytes.to_vec()
+    }
+}
+
+fn eddsa_digest(signature_r: &[u8], public_key: &[u8], msg: &[u8]) -> Vec<u8>
+{
+    let mut ctx = Sha512::new();
+    ctx.input(signature_r);
+    ctx.input(public_key);
+    ctx.input(msg);
+    ctx.result().as_slice().to_vec()
+}
+
+fn digest_scalar(digest: &[u8]) -> Vec<u8> {
+    assert_eq!(digest.len(), 512/8);
+    let mut copy = [0; 512/8];
+    copy.copy_from_slice(digest);
+    x25519_sc_reduce(&mut copy);
+    copy[..32].to_vec()
+}
+
+#[cfg(test)]
+fn run_signing_testcase(case: HashMap<String,(bool,Vec<u8>)>)
+{
+    let (negr, rbytes) = case.get("r").unwrap();
+    let (negu, ubytes) = case.get("u").unwrap();
+    let (negm, mbytes) = case.get("m").unwrap();
+    let (negs, sbytes) = case.get("s").unwrap();
+
+    assert!(!negr && !negu && !negm && !negs);
+    let keypair = ED25519KeyPair::from_seed(rbytes);
+    assert_eq!(ubytes, &keypair.public.bytes.to_vec());
+    let mut privpub = Vec::new();
+    privpub.append(&mut rbytes.clone());
+    privpub.append(&mut ubytes.clone());
+    let sig = keypair.private.sign(&mbytes);
+    assert_eq!(sig.len(), sbytes.len());
+    assert!(sig.iter().eq(sbytes.iter()));
+    assert!(keypair.public.verify(&mbytes, &sig));
+}
+
+#[cfg(test)]
+#[test]
+fn rfc8072() {
+    let fname = "testdata/ed25519/rfc8032.test";
+    run_test(fname.to_string(), 4, run_signing_testcase);
+}
+
+#[cfg(test)]
+#[test]
+fn signing() {
+    let fname = "testdata/ed25519/sign.test";
+    run_test(fname.to_string(), 4, run_signing_testcase);
+}

src/ed25519/point.rs

@@ -0,0 +1,733 @@
+#[cfg(test)]
+use testing::run_test;
+
+use ed25519::fe::*;
+use ed25519::constants::*;
+use std::ops::*;
+
+// This is ge_p3 in the original source code
+#[derive(Clone,Debug,PartialEq)]
+pub struct Point {
+    pub x: FieldElement,
+    pub y: FieldElement,
+    pub z: FieldElement,
+    pub t: FieldElement
+}
+
+impl Point {
+    fn zero() -> Point
+    {
+        Point {
+            x: FieldElement::zero(),
+            y: FieldElement::one(),
+            z: FieldElement::one(),
+            t: FieldElement::zero(),
+        }
+    }
+
+    #[cfg(test)]
+    fn load_test_value(xs: &[u8]) -> Point {
+        assert!(xs.len() == 160);
+        Point {
+            x: test_from_bytes(&xs[0..40]),
+            y: test_from_bytes(&xs[40..80]),
+            z: test_from_bytes(&xs[80..120]),
+            t: test_from_bytes(&xs[120..])
+        }
+    }
+  
+    /// Convert 32 bytes into an ED25519 point. This routine is not
+    /// statically timed, so don't use it if that's important to you.
+    pub fn from_bytes(s: &[u8]) -> Option<Point>
+    {
+        let hy = FieldElement::from_bytes(s);
+        let hz = FieldElement::one();
+        let mut u = hy.square();
+        let mut v = &u * &D;
+        u = &u - &hz; /* u = y^2-1 */
+        v += &hz;
+  
+        let mut v3 = v.square();
+        v3 *= &v; /* v3 = v^3 */
+        let mut hx = v3.square();
+        hx *= &v;
+        hx *= &u; /* x = uv^7 */
+        hx = hx.pow22523(); /* x = (uv^7)^((q-5)/8) */
+        hx *= &v3;
+        hx *= &u; /* x = uv^3(uv^7)^((q-5)/8) */
+  
+        let mut vxx = hx.square();
+        vxx *= &v;
+        let mut check = &vxx - &u; /* vx^2-u */
+        if check.isnonzero() {
+            check = &vxx + &u;
+            if check.isnonzero() {
+                return None;
+            }
+            hx *= &SQRTM1;
+        }
+  
+        if hx.isnegative() != ((s[31] >> 7) == 1) {
+            hx = -&hx;
+        }
+  
+        let ht = &hx * &hy;
+        return Some(Point{ x: hx, y: hy, z: hz, t: ht });
+    }
+  
+    pub fn encode(&self) -> Vec<u8>
+    {
+        into_encoded_point(&self.x, &self.y, &self.z)
+    }
+  
+    pub fn invert(&self) -> Point
+    {
+        Point {
+            x: -&self.x,
+            y: self.y.clone(),
+            z: self.z.clone(),
+            t: -&self.t,
+        }
+    }
+}
+
+const D: FieldElement = FieldElement {
+    value: [-10913610, 13857413, -15372611, 6949391,   114729,
+            -8787816,  -6275908, -3247719,  -18696448, -12055116]
+};
+
+const SQRTM1: FieldElement = FieldElement {
+    value: [-32595792, -7943725,  9377950,  3500415, 12389472,
+            -272473,   -25146209, -2005654, 326686,  11406482]
+};
+
+#[cfg(test)]
+#[test]
+fn from_bytes_vartime() {
+    let fname = "testdata/ed25519/fbv.test";
+    run_test(fname.to_string(), 3, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+        let (negc, cbytes) = case.get("c").unwrap();
+
+        assert!(!nega && !negb && !negc);
+        let target = Point::load_test_value(&cbytes);
+        let mine = Point::from_bytes(&abytes);
+        if bbytes.len() < cbytes.len() {
+            assert!(mine.is_none());
+        } else {
+            assert_eq!(target, mine.unwrap());
+        }
+    });
+}
+
+#[derive(Debug,PartialEq)]
+pub struct Point2 {
+    pub x: FieldElement,
+    pub y: FieldElement,
+    pub z: FieldElement,
+}
+
+impl Point2 {
+    pub fn zero() -> Point2
+    {
+        Point2 {
+            x: FieldElement::zero(),
+            y: FieldElement::one(),
+            z: FieldElement::one()  
+        }
+    }
+  
+    #[cfg(test)]
+    fn load_test_value(xs: &[u8]) -> Point2 {
+        assert!(xs.len() == 120);
+        Point2 {
+            x: test_from_bytes(&xs[0..40]),
+            y: test_from_bytes(&xs[40..80]),
+            z: test_from_bytes(&xs[80..120]),
+        }
+    }
+  
+    pub fn encode(&self) -> Vec<u8>
+    {
+        into_encoded_point(&self.x, &self.y, &self.z)
+    }
+}
+
+impl<'a> From<&'a Point> for Point2 {
+    fn from(p: &Point) -> Point2 {
+        Point2 {
+            x: p.x.clone(),
+            y: p.y.clone(),
+            z: p.z.clone(),
+        }
+    }
+}
+
+#[derive(Debug,PartialEq)]
+pub struct PointP1P1 {
+    x: FieldElement,
+    y: FieldElement,
+    z: FieldElement,
+    t: FieldElement
+}
+
+impl PointP1P1 {
+    #[cfg(test)]
+    fn load_test_value(xs: &[u8]) -> PointP1P1 {
+        assert!(xs.len() == 160);
+        PointP1P1 {
+            x: test_from_bytes(&xs[0..40]),
+            y: test_from_bytes(&xs[40..80]),
+            z: test_from_bytes(&xs[80..120]),
+            t: test_from_bytes(&xs[120..])
+        }
+    }
+}
+
+#[derive(Debug,PartialEq)]
+struct Cached {
+    yplusx:  FieldElement,
+    yminusx: FieldElement,
+    z:       FieldElement,
+    t2d:     FieldElement
+}
+
+impl Cached
+{
+    fn new() -> Cached
+    {
+        Cached {
+            yplusx: FieldElement::new(),
+            yminusx: FieldElement::new(),
+            z: FieldElement::new(),
+            t2d: FieldElement::new()
+        }
+    }
+  
+    #[cfg(test)]
+    fn load_test_value(xs: &[u8]) -> Cached {
+        assert!(xs.len() == 160);
+        Cached {
+            yplusx: test_from_bytes(&xs[0..40]),
+            yminusx: test_from_bytes(&xs[40..80]),
+            z: test_from_bytes(&xs[80..120]),
+            t2d: test_from_bytes(&xs[120..])
+        }
+    }
+}
+
+const D2: FieldElement = FieldElement {
+    value: [-21827239, -5839606,  -30745221, 13898782, 229458,
+            15978800,  -12551817, -6495438,  29715968, 9444199]
+};
+
+impl<'a> From<&'a Point> for Cached
+{
+    fn from(p: &Point) -> Cached
+    {
+        Cached {
+            yplusx: &p.y + &p.x,
+            yminusx: &p.y - &p.x,
+            z: p.z.clone(),
+            t2d: &p.t * &D2,
+        }    
+    }
+}
+
+impl<'a> From<&'a PointP1P1> for Point2
+{
+    fn from(p: &PointP1P1) -> Point2
+    {
+        Point2 {
+            x: &p.x * &p.t,
+            y: &p.y * &p.z,
+            z: &p.z * &p.t,
+        }
+    }
+}
+
+impl<'a> From<&'a PointP1P1> for Point 
+{
+    fn from(p: &PointP1P1) -> Point
+    {
+        Point {
+            x: &p.x * &p.t,
+            y: &p.y * &p.z,
+            z: &p.z * &p.t,
+            t: &p.x * &p.y,
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn conversion() {
+    let fname = "testdata/ed25519/conversion.test";
+    run_test(fname.to_string(), 6, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negc, cbytes) = case.get("c").unwrap();
+        let (negt, tbytes) = case.get("t").unwrap();
+        let (nego, obytes) = case.get("o").unwrap();
+        let (negd, dbytes) = case.get("d").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+
+        let a = Point::load_test_value(&abytes);
+        let c = Cached::load_test_value(&cbytes);
+        let t = Point2::load_test_value(&tbytes);
+        let o = PointP1P1::load_test_value(&obytes);
+        let d = Point2::load_test_value(&dbytes);
+        let b = Point::load_test_value(&bbytes);
+
+        assert!(!nega && !negc && !negt && !nego && !negd && !negb);
+
+        let myc = Cached::from(&a);
+        assert_eq!(myc, c);
+
+        let myt = Point2::from(&a);
+        assert_eq!(myt, t);
+
+        let myo = a.double();
+        assert_eq!(myo, o);
+
+        let myd = Point2::from(&o);
+        assert_eq!(myd, d);
+
+        let myb = Point::from(&o);
+        assert_eq!(myb, b);
+    });
+}
+
+/* r = 2 * p */
+impl Point2 {
+    fn double(&self) -> PointP1P1
+    {
+        let x0 = self.x.square();
+        let z0 = self.y.square();
+        let t0 = self.z.sq2();
+        let y0 = &self.x + &self.y;
+        let ry = &z0 + &x0;
+        let rz = &z0 - &x0;
+        let rx = &y0.square() - &ry;
+        let rt = &t0 - &rz;
+        PointP1P1 { x: rx, y: ry, z: rz, t: rt }
+    }
+}
+
+/* r = 2 * p */
+impl Point {
+    fn double(&self) -> PointP1P1
+    {
+        Point2::from(self).double()
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn double() {
+    let fname = "testdata/ed25519/pt_double.test";
+    run_test(fname.to_string(), 4, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+        let (negc, cbytes) = case.get("c").unwrap();
+        let (negd, dbytes) = case.get("d").unwrap();
+
+        assert!(!nega && !negb && !negc && !negd);
+        let a = Point::load_test_value(abytes);
+        let b = PointP1P1::load_test_value(bbytes);
+        let c = Point2::load_test_value(cbytes);
+        let d = PointP1P1::load_test_value(dbytes);
+
+        let myb = a.double();
+        assert_eq!(myb, b);
+        let myd = c.double();
+        assert_eq!(myd, d);
+    });
+}
+
+impl<'a,'b> Add<&'a Precomp> for &'b Point
+{
+    type Output = PointP1P1;
+
+    fn add(self, q: &Precomp) -> PointP1P1
+    {
+        let mut rx;
+        let mut ry;
+        let mut rz;
+        let mut rt;
+
+        rx = &self.y + &self.x;
+        ry = &self.y - &self.x;
+        rz = &rx * &q.yplusx;
+        ry *= &q.yminusx;
+        rt = &q.xy2d * &self.t;
+        let t0 = &self.z + &self.z;
+        rx = &rz - &ry;
+        ry += &rz;
+        rz = &t0 + &rt;
+        rt = &t0 - &rt;
+
+        PointP1P1 { x: rx, y: ry, z: rz, t: rt }
+    }
+}
+
+impl<'a,'b> Sub<&'a Precomp> for &'b Point
+{
+    type Output = PointP1P1;
+
+    /* r = p - q */
+    fn sub(self, q: &Precomp) -> PointP1P1
+    {
+        let mut rx = &self.y + &self.x;
+        let mut ry = &self.y - &self.x;
+        let mut rz = &rx * &q.yminusx;
+        ry *= &q.yplusx;
+        let mut rt = &q.xy2d * &self.t;
+        let t0 = &self.z + &self.z;
+        rx = &rz - &ry;
+        ry += &rz;
+        rz = &t0 - &rt;
+        rt += &t0;
+        PointP1P1{ x: rx, y: ry, z: rz, t: rt }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn maddsub() {
+    let fname = "testdata/ed25519/maddsub.test";
+    run_test(fname.to_string(), 4, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+        let (negc, cbytes) = case.get("c").unwrap();
+        let (negd, dbytes) = case.get("d").unwrap();
+
+        assert!(!nega && !negb && !negc && !negd);
+        let a = Point::load_test_value(abytes);
+        let b = PointP1P1::load_test_value(bbytes);
+        let c = Precomp::load_test_value(cbytes);
+        let d = PointP1P1::load_test_value(dbytes);
+
+        let myb = &a + &c;
+        assert_eq!(myb, b);
+        let myd = &a - &c;
+        assert_eq!(myd, d);
+    });
+}
+
+impl<'a,'b> Add<&'a Cached> for &'b Point
+{
+    type Output = PointP1P1;
+
+    fn add(self, q: &Cached) -> PointP1P1
+    {
+        let mut rx;
+        let mut ry;
+        let mut rz;
+        let mut rt;
+
+        rx = &self.y + &self.x;
+        ry = &self.y - &self.x;
+        rz = &rx * &q.yplusx;
+        ry *= &q.yminusx;
+        rt = &q.t2d * &self.t;
+        rx = &self.z * &q.z;
+        let t0 = &rx + &rx;
+        rx = &rz - &ry;
+        ry += &rz;
+        rz = &t0 + &rt;
+        rt = &t0 - &rt;
+
+        PointP1P1{ x: rx, y: ry, z: rz, t: rt }
+    }
+}
+
+impl<'a,'b> Sub<&'a Cached> for &'b Point
+{
+    type Output = PointP1P1;
+
+    fn sub(self, q: &Cached) -> PointP1P1
+    {
+        let mut rx;
+        let mut ry;
+        let mut rz;
+        let mut rt;
+
+        rx = &self.y + &self.x;
+        ry = &self.y - &self.x;
+        rz = &rx * &q.yminusx;
+        ry *= &q.yplusx;
+        rt = &q.t2d * &self.t;
+        rx = &self.z * &q.z;
+        let t0 = &rx + &rx;
+        rx = &rz - &ry;
+        ry += &rz;
+        rz = &t0 - &rt;
+        rt += &t0;
+
+        PointP1P1{ x: rx, y: ry, z: rz, t: rt }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn addsub() {
+    let fname = "testdata/ed25519/ptaddsub.test";
+    run_test(fname.to_string(), 4, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+        let (negc, cbytes) = case.get("c").unwrap();
+        let (negd, dbytes) = case.get("d").unwrap();
+
+        assert!(!nega && !negb && !negc && !negd);
+        let a = Point::load_test_value(abytes);
+        let b = PointP1P1::load_test_value(bbytes);
+        let c = Cached::load_test_value(cbytes);
+        let d = PointP1P1::load_test_value(dbytes);
+
+        let myb = &a + &c;
+        assert_eq!(myb, b);
+        let myd = &a - &c;
+        assert_eq!(myd, d);
+    });
+}
+
+impl Point {
+    /* h = a * B
+     * where a = a[0]+256*a[1]+...+256^31 a[31]
+     * B is the Ed25519 base point (x,4/5) with x positive.
+     *
+     * Preconditions:
+     *   a[31] <= 127 */
+    pub fn scalarmult_base(a: &[u8]) -> Point
+    {
+      let mut e: [i8; 64] = [0; 64];
+      for i in 0..32 {
+          e[2 * i + 0] = ((a[i] >> 0) & 15) as i8;
+          e[2 * i + 1] = ((a[i] >> 4) & 15) as i8;
+      }
+      /* each e[i] is between 0 and 15 */
+      /* e[63] is between 0 and 7 */
+  
+      let mut carry = 0;
+      for i in 0..63 {
+          e[i] += carry;
+          carry = e[i] + 8;
+          carry >>= 4;
+          e[i] -= carry << 4;
+      }
+      e[63] += carry;
+      /* each e[i] is between -8 and 8 */
+  
+      let mut r;
+      let mut t;
+  
+      let mut h = Point::zero();
+      for i in &[1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43,45,47,49,51,53,55,57,59,61,63] {
+          t = Precomp::table_select(*i / 2, e[*i as usize]);
+          r = &h + &t;
+          h = Point::from(&r);
+      }
+  
+      r = h.double();
+      let mut s = Point2::from(&r);
+      r = s.double();
+      s = Point2::from(&r);
+      r = s.double();
+      s = Point2::from(&r);
+      r = s.double();
+      h = Point::from(&r);
+  
+      for i in &[0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62] {
+          t = Precomp::table_select(*i / 2, e[*i as usize]);
+          r = &h + &t;
+          h = Point::from(&r);
+      }
+
+      h
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn scalarmult_base() {
+    let fname = "testdata/ed25519/scalar_mult.test";
+    run_test(fname.to_string(), 2, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+
+        assert!(!nega && !negb);
+        let b    = Point::load_test_value(bbytes);
+        let mine = Point::scalarmult_base(&abytes);
+        assert_eq!(mine, b);
+    });
+}
+
+fn slide(r: &mut [i8], a: &[u8])
+{
+    for i in 0..256 {
+        r[i] = (1 & (a[i >> 3] >> (i & 7))) as i8;
+    }
+  
+    for i in 0..256 {
+        if r[i] != 0 {
+            let mut b = 1;
+            while (b <= 6) && ((i + b) < 256) {
+                if r[i + b] != 0 {
+                    if r[i] + (r[i + b] << b) <= 15 {
+                        r[i] += r[i + b] << b;
+                        r[i + b] = 0;
+                    } else if r[i] - (r[i + b] << b) >= -15 {
+                        r[i] -= r[i + b] << b;
+                        for k in (i+b)..256 {
+                          if r[k] == 0 {
+                            r[k] = 1;
+                            break;
+                          }
+                          r[k] = 0;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+                b += 1;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn helper_slide() {
+    let fname = "testdata/ed25519/slide.test";
+    run_test(fname.to_string(), 2, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+
+        assert!(!nega && !negb);
+        let mut mine = [0; 256];
+        slide(&mut mine, &abytes);
+        for i in 0..256 {
+          assert_eq!(mine[i], bbytes[i] as i8);
+        }
+    });
+}
+
+impl Point2
+{
+    /* r = a * A + b * B
+     * where a = a[0]+256*a[1]+...+256^31 a[31].
+     * and b = b[0]+256*b[1]+...+256^31 b[31].
+     * B is the Ed25519 base point (x,4/5) with x positive. */
+    #[allow(non_snake_case)]
+    pub fn double_scalarmult_vartime(a: &[u8], A: &Point, b: &[u8]) -> Point2
+    {
+        let mut aslide: [i8; 256] = [0; 256];
+        let mut bslide: [i8; 256] = [0; 256];
+        #[allow(non_snake_case)]
+        let mut Ai: [Cached; 8] = [Cached::new(), Cached::new(), Cached::new(), Cached::new(),
+                                   Cached::new(), Cached::new(), Cached::new(), Cached::new()];
+        #[allow(non_snake_case)]
+    
+        slide(&mut aslide, &a);
+        slide(&mut bslide, &b);
+    
+        Ai[0] = Cached::from(A);
+        let mut t = A.double();
+        let A2 = Point::from(&t);
+        t = &A2 + &Ai[0];
+        let mut u = Point::from(&t);
+        Ai[1] = Cached::from(&u);
+        t = &A2 + &Ai[1];
+        u = Point::from(&t);
+        Ai[2] = Cached::from(&u);
+        t = &A2 + &Ai[2];
+        u = Point::from(&t);
+        Ai[3] = Cached::from(&u);
+        t = &A2 + &Ai[3];
+        u = Point::from(&t);
+        Ai[4] = Cached::from(&u);
+        t = &A2 + &Ai[4];
+        u = Point::from(&t);
+        Ai[5] = Cached::from(&u);
+        t = &A2 + &Ai[5];
+        u = Point::from(&t);
+        Ai[6] = Cached::from(&u);
+        t = &A2 + &Ai[6];
+        u = Point::from(&t);
+        Ai[7] = Cached::from(&u);
+    
+        let mut r = Point2::zero();
+    
+        let mut i: i32 = 255;
+        loop {
+            if (aslide[i as usize] != 0) || (bslide[i as usize] != 0) {
+                break;
+            }
+            i -= 1;
+            if i < 0 {
+                break;
+            }
+        }
+    
+        while i >= 0 {
+            t = r.double();
+      
+            if aslide[i as usize] > 0 {
+                u = Point::from(&t);
+                let idx = (aslide[i as usize] / 2) as usize;
+                t = &u + &Ai[idx]
+            } else if aslide[i as usize] < 0 {
+                u = Point::from(&t);
+                let idx = ((-aslide[i as usize]) / 2) as usize;
+                t = &u - &Ai[idx];
+            }
+      
+            if bslide[i as usize] > 0 {
+                u = Point::from(&t);
+                let idx = (bslide[i as usize] / 2) as usize;
+                t = &u + &BI[idx];
+            } else if bslide[i as usize] < 0 {
+                u = Point::from(&t);
+                let idx = ((-bslide[i as usize]) / 2) as usize;
+                t = &u - &BI[idx];
+            }
+    
+            r = Point2::from(&t); 
+            i -= 1;
+        }
+    
+        r
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn double_scalarmult() {
+    let fname = "testdata/ed25519/scalar_mult_gen.test";
+    run_test(fname.to_string(), 4, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+        let (negc, cbytes) = case.get("c").unwrap();
+        let (negd, dbytes) = case.get("d").unwrap();
+
+        assert!(!nega && !negb && !negc && !negd);
+        let b = Point::load_test_value(bbytes);
+        let d = Point2::load_test_value(dbytes);
+        let mine = Point2::double_scalarmult_vartime(&abytes, &b, &cbytes);
+        assert_eq!(mine, d);
+    });
+}
+
+fn into_encoded_point(x: &FieldElement, y: &FieldElement, z: &FieldElement) -> Vec<u8>
+{
+    let recip = z.invert();
+    let x_over_z = x * &recip;
+    let y_over_z = y * &recip;
+    let mut bytes = y_over_z.to_bytes();
+    let sign_bit = if x_over_z.isnegative() { 1 } else { 0 };
+    // The preceding computations must execute in constant time, but this
+    // doesn't need to.
+    bytes[31] ^= sign_bit << 7;
+    bytes
+}

src/ed25519/scalars.rs

@@ -0,0 +1,881 @@
+use ed25519::loads::{load3,load4};
+#[cfg(test)]
+use testing::run_test;
+
+/* The set of scalars is \Z/l
+ * where l = 2^252 + 27742317777372353535851937790883648493. */
+
+/* Input:
+ *   s[0]+256*s[1]+...+256^63*s[63] = s
+ *
+ * Output:
+ *   s[0]+256*s[1]+...+256^31*s[31] = s mod l
+ *   where l = 2^252 + 27742317777372353535851937790883648493.
+ *   Overwrites s in place. */
+pub fn x25519_sc_reduce(s: &mut [u8])
+{
+    let mut s0  : i64 = 2097151 & load3(s) as i64;
+    let mut s1  : i64 = 2097151 & (load4(&s[2..]) >> 5) as i64;
+    let mut s2  : i64 = 2097151 & (load3(&s[5..]) >> 2) as i64;
+    let mut s3  : i64 = 2097151 & (load4(&s[7..]) >> 7) as i64;
+    let mut s4  : i64 = 2097151 & (load4(&s[10..]) >> 4) as i64;
+    let mut s5  : i64 = 2097151 & (load3(&s[13..]) >> 1) as i64;
+    let mut s6  : i64 = 2097151 & (load4(&s[15..]) >> 6) as i64;
+    let mut s7  : i64 = 2097151 & (load3(&s[18..]) >> 3) as i64;
+    let mut s8  : i64 = 2097151 & load3(&s[21..]) as i64;
+    let mut s9  : i64 = 2097151 & (load4(&s[23..]) >> 5) as i64;
+    let mut s10 : i64 = 2097151 & (load3(&s[26..]) >> 2) as i64;
+    let mut s11 : i64 = 2097151 & (load4(&s[28..]) >> 7) as i64;
+    let mut s12 : i64 = 2097151 & (load4(&s[31..]) >> 4) as i64;
+    let mut s13 : i64 = 2097151 & (load3(&s[34..]) >> 1) as i64;
+    let mut s14 : i64 = 2097151 & (load4(&s[36..]) >> 6) as i64;
+    let mut s15 : i64 = 2097151 & (load3(&s[39..]) >> 3) as i64;
+    let mut s16 : i64 = 2097151 & load3(&s[42..]) as i64;
+    let mut s17 : i64 = 2097151 & (load4(&s[44..]) >> 5) as i64;
+    let     s18 : i64 = 2097151 & (load3(&s[47..]) >> 2) as i64;
+    let     s19 : i64 = 2097151 & (load4(&s[49..]) >> 7) as i64;
+    let     s20 : i64 = 2097151 & (load4(&s[52..]) >> 4) as i64;
+    let     s21 : i64 = 2097151 & (load3(&s[55..]) >> 1) as i64;
+    let     s22 : i64 = 2097151 & (load4(&s[57..]) >> 6) as i64;
+    let     s23 : i64 = (load4(&s[60..]) >> 3) as i64 as i64;
+    let mut carry0 : i64;
+    let mut carry1 : i64;
+    let mut carry2 : i64;
+    let mut carry3 : i64;
+    let mut carry4 : i64;
+    let mut carry5 : i64;
+    let mut carry6 : i64;
+    let mut carry7 : i64;
+    let mut carry8 : i64;
+    let mut carry9 : i64;
+    let mut carry10 : i64;
+    let mut carry11 : i64;
+    let     carry12 : i64;
+    let     carry13 : i64;
+    let     carry14 : i64;
+    let     carry15 : i64;
+    let     carry16 : i64;
+  
+    s11 += s23 * 666643;
+    s12 += s23 * 470296;
+    s13 += s23 * 654183;
+    s14 -= s23 * 997805;
+    s15 += s23 * 136657;
+    s16 -= s23 * 683901;
+    //s23 = 0;
+  
+    s10 += s22 * 666643;
+    s11 += s22 * 470296;
+    s12 += s22 * 654183;
+    s13 -= s22 * 997805;
+    s14 += s22 * 136657;
+    s15 -= s22 * 683901;
+    //s22 = 0;
+  
+    s9 += s21 * 666643;
+    s10 += s21 * 470296;
+    s11 += s21 * 654183;
+    s12 -= s21 * 997805;
+    s13 += s21 * 136657;
+    s14 -= s21 * 683901;
+    //s21 = 0;
+  
+    s8 += s20 * 666643;
+    s9 += s20 * 470296;
+    s10 += s20 * 654183;
+    s11 -= s20 * 997805;
+    s12 += s20 * 136657;
+    s13 -= s20 * 683901;
+    //s20 = 0;
+  
+    s7 += s19 * 666643;
+    s8 += s19 * 470296;
+    s9 += s19 * 654183;
+    s10 -= s19 * 997805;
+    s11 += s19 * 136657;
+    s12 -= s19 * 683901;
+    //s19 = 0;
+  
+    s6 += s18 * 666643;
+    s7 += s18 * 470296;
+    s8 += s18 * 654183;
+    s9 -= s18 * 997805;
+    s10 += s18 * 136657;
+    s11 -= s18 * 683901;
+    //s18 = 0;
+  
+    carry6 = (s6 + (1 << 20)) >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry8 = (s8 + (1 << 20)) >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry10 = (s10 + (1 << 20)) >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+    carry12 = (s12 + (1 << 20)) >> 21;
+    s13 += carry12;
+    s12 -= carry12 << 21;
+    carry14 = (s14 + (1 << 20)) >> 21;
+    s15 += carry14;
+    s14 -= carry14 << 21;
+    carry16 = (s16 + (1 << 20)) >> 21;
+    s17 += carry16;
+    s16 -= carry16 << 21;
+  
+    carry7 = (s7 + (1 << 20)) >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry9 = (s9 + (1 << 20)) >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry11 = (s11 + (1 << 20)) >> 21;
+    s12 += carry11;
+    s11 -= carry11 << 21;
+    carry13 = (s13 + (1 << 20)) >> 21;
+    s14 += carry13;
+    s13 -= carry13 << 21;
+    carry15 = (s15 + (1 << 20)) >> 21;
+    s16 += carry15;
+    s15 -= carry15 << 21;
+  
+    s5 += s17 * 666643;
+    s6 += s17 * 470296;
+    s7 += s17 * 654183;
+    s8 -= s17 * 997805;
+    s9 += s17 * 136657;
+    s10 -= s17 * 683901;
+    //s17 = 0;
+  
+    s4 += s16 * 666643;
+    s5 += s16 * 470296;
+    s6 += s16 * 654183;
+    s7 -= s16 * 997805;
+    s8 += s16 * 136657;
+    s9 -= s16 * 683901;
+    //s16 = 0;
+  
+    s3 += s15 * 666643;
+    s4 += s15 * 470296;
+    s5 += s15 * 654183;
+    s6 -= s15 * 997805;
+    s7 += s15 * 136657;
+    s8 -= s15 * 683901;
+    //s15 = 0;
+  
+    s2 += s14 * 666643;
+    s3 += s14 * 470296;
+    s4 += s14 * 654183;
+    s5 -= s14 * 997805;
+    s6 += s14 * 136657;
+    s7 -= s14 * 683901;
+    //s14 = 0;
+  
+    s1 += s13 * 666643;
+    s2 += s13 * 470296;
+    s3 += s13 * 654183;
+    s4 -= s13 * 997805;
+    s5 += s13 * 136657;
+    s6 -= s13 * 683901;
+    //s13 = 0;
+  
+    s0 += s12 * 666643;
+    s1 += s12 * 470296;
+    s2 += s12 * 654183;
+    s3 -= s12 * 997805;
+    s4 += s12 * 136657;
+    s5 -= s12 * 683901;
+    s12 = 0;
+  
+    carry0 = (s0 + (1 << 20)) >> 21;
+    s1 += carry0;
+    s0 -= carry0 << 21;
+    carry2 = (s2 + (1 << 20)) >> 21;
+    s3 += carry2;
+    s2 -= carry2 << 21;
+    carry4 = (s4 + (1 << 20)) >> 21;
+    s5 += carry4;
+    s4 -= carry4 << 21;
+    carry6 = (s6 + (1 << 20)) >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry8 = (s8 + (1 << 20)) >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry10 = (s10 + (1 << 20)) >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+  
+    carry1 = (s1 + (1 << 20)) >> 21;
+    s2 += carry1;
+    s1 -= carry1 << 21;
+    carry3 = (s3 + (1 << 20)) >> 21;
+    s4 += carry3;
+    s3 -= carry3 << 21;
+    carry5 = (s5 + (1 << 20)) >> 21;
+    s6 += carry5;
+    s5 -= carry5 << 21;
+    carry7 = (s7 + (1 << 20)) >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry9 = (s9 + (1 << 20)) >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry11 = (s11 + (1 << 20)) >> 21;
+    s12 += carry11;
+    s11 -= carry11 << 21;
+  
+    s0 += s12 * 666643;
+    s1 += s12 * 470296;
+    s2 += s12 * 654183;
+    s3 -= s12 * 997805;
+    s4 += s12 * 136657;
+    s5 -= s12 * 683901;
+    s12 = 0;
+  
+    carry0 = s0 >> 21;
+    s1 += carry0;
+    s0 -= carry0 << 21;
+    carry1 = s1 >> 21;
+    s2 += carry1;
+    s1 -= carry1 << 21;
+    carry2 = s2 >> 21;
+    s3 += carry2;
+    s2 -= carry2 << 21;
+    carry3 = s3 >> 21;
+    s4 += carry3;
+    s3 -= carry3 << 21;
+    carry4 = s4 >> 21;
+    s5 += carry4;
+    s4 -= carry4 << 21;
+    carry5 = s5 >> 21;
+    s6 += carry5;
+    s5 -= carry5 << 21;
+    carry6 = s6 >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry7 = s7 >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry8 = s8 >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry9 = s9 >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry10 = s10 >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+    carry11 = s11 >> 21;
+    s12 += carry11;
+    s11 -= carry11 << 21;
+  
+    s0 += s12 * 666643;
+    s1 += s12 * 470296;
+    s2 += s12 * 654183;
+    s3 -= s12 * 997805;
+    s4 += s12 * 136657;
+    s5 -= s12 * 683901;
+    //s12 = 0;
+  
+    carry0 = s0 >> 21;
+    s1 += carry0;
+    s0 -= carry0 << 21;
+    carry1 = s1 >> 21;
+    s2 += carry1;
+    s1 -= carry1 << 21;
+    carry2 = s2 >> 21;
+    s3 += carry2;
+    s2 -= carry2 << 21;
+    carry3 = s3 >> 21;
+    s4 += carry3;
+    s3 -= carry3 << 21;
+    carry4 = s4 >> 21;
+    s5 += carry4;
+    s4 -= carry4 << 21;
+    carry5 = s5 >> 21;
+    s6 += carry5;
+    s5 -= carry5 << 21;
+    carry6 = s6 >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry7 = s7 >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry8 = s8 >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry9 = s9 >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry10 = s10 >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+  
+    s[0] = (s0 >> 0) as u8;
+    s[1] = (s0 >> 8) as u8;
+    s[2] = ((s0 >> 16) | (s1 << 5)) as u8;
+    s[3] = (s1 >> 3) as u8;
+    s[4] = (s1 >> 11) as u8;
+    s[5] = ((s1 >> 19) | (s2 << 2)) as u8;
+    s[6] = (s2 >> 6) as u8;
+    s[7] = ((s2 >> 14) | (s3 << 7)) as u8;
+    s[8] = (s3 >> 1) as u8;
+    s[9] = (s3 >> 9) as u8;
+    s[10] = ((s3 >> 17) | (s4 << 4)) as u8;
+    s[11] = (s4 >> 4) as u8;
+    s[12] = (s4 >> 12) as u8;
+    s[13] = ((s4 >> 20) | (s5 << 1)) as u8;
+    s[14] = (s5 >> 7) as u8;
+    s[15] = ((s5 >> 15) | (s6 << 6)) as u8;
+    s[16] = (s6 >> 2) as u8;
+    s[17] = (s6 >> 10) as u8;
+    s[18] = ((s6 >> 18) | (s7 << 3)) as u8;
+    s[19] = (s7 >> 5) as u8;
+    s[20] = (s7 >> 13) as u8;
+    s[21] = (s8 >> 0) as u8;
+    s[22] = (s8 >> 8) as u8;
+    s[23] = ((s8 >> 16) | (s9 << 5)) as u8;
+    s[24] = (s9 >> 3) as u8;
+    s[25] = (s9 >> 11) as u8;
+    s[26] = ((s9 >> 19) | (s10 << 2)) as u8;
+    s[27] = (s10 >> 6) as u8;
+    s[28] = ((s10 >> 14) | (s11 << 7)) as u8;
+    s[29] = (s11 >> 1) as u8;
+    s[30] = (s11 >> 9) as u8;
+    s[31] = (s11 >> 17) as u8;
+}
+
+#[cfg(test)]
+#[test]
+fn reduce() {
+    let fname = "testdata/ed25519/reduce.test";
+    run_test(fname.to_string(), 2, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+
+        assert!(!nega && !negb);
+        assert_eq!(abytes.len(), 64);
+        assert_eq!(bbytes.len(), 32);
+        let mut copy = abytes.clone();
+        x25519_sc_reduce(&mut copy);
+        assert_eq!(&copy[0..32], &bbytes[0..]);
+    });
+}
+
+/* Input:
+ *   a[0]+256*a[1]+...+256^31*a[31] = a
+ *   b[0]+256*b[1]+...+256^31*b[31] = b
+ *   c[0]+256*c[1]+...+256^31*c[31] = c
+ *
+ * Output:
+ *   s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
+ *   where l = 2^252 + 27742317777372353535851937790883648493. */
+pub fn x25519_sc_muladd(s: &mut [u8], a: &[u8], b: &[u8], c: &[u8])
+{
+    let a0  : i64 = 2097151 & load3(a) as i64;
+    let a1  : i64 = 2097151 & (load4(&a[2..]) >> 5) as i64;
+    let a2  : i64 = 2097151 & (load3(&a[5..]) >> 2) as i64;
+    let a3  : i64 = 2097151 & (load4(&a[7..]) >> 7) as i64;
+    let a4  : i64 = 2097151 & (load4(&a[10..]) >> 4) as i64;
+    let a5  : i64 = 2097151 & (load3(&a[13..]) >> 1) as i64;
+    let a6  : i64 = 2097151 & (load4(&a[15..]) >> 6) as i64;
+    let a7  : i64 = 2097151 & (load3(&a[18..]) >> 3) as i64;
+    let a8  : i64 = 2097151 &  load3(&a[21..]) as i64;
+    let a9  : i64 = 2097151 & (load4(&a[23..]) >> 5) as i64;
+    let a10 : i64 = 2097151 & (load3(&a[26..]) >> 2) as i64;
+    let a11 : i64 =           (load4(&a[28..]) >> 7) as i64;
+    let b0  : i64 = 2097151 &  load3(b) as i64;
+    let b1  : i64 = 2097151 & (load4(&b[2..]) >> 5) as i64;
+    let b2  : i64 = 2097151 & (load3(&b[5..]) >> 2) as i64;
+    let b3  : i64 = 2097151 & (load4(&b[7..]) >> 7) as i64;
+    let b4  : i64 = 2097151 & (load4(&b[10..]) >> 4) as i64;
+    let b5  : i64 = 2097151 & (load3(&b[13..]) >> 1) as i64;
+    let b6  : i64 = 2097151 & (load4(&b[15..]) >> 6) as i64;
+    let b7  : i64 = 2097151 & (load3(&b[18..]) >> 3) as i64;
+    let b8  : i64 = 2097151 &  load3(&b[21..]) as i64;
+    let b9  : i64 = 2097151 & (load4(&b[23..]) >> 5) as i64;
+    let b10 : i64 = 2097151 & (load3(&b[26..]) >> 2) as i64;
+    let b11 : i64 =           (load4(&b[28..]) >> 7) as i64;
+    let c0  : i64 = 2097151 &  load3(c) as i64;
+    let c1  : i64 = 2097151 & (load4(&c[2..]) >> 5) as i64;
+    let c2  : i64 = 2097151 & (load3(&c[5..]) >> 2) as i64;
+    let c3  : i64 = 2097151 & (load4(&c[7..]) >> 7) as i64;
+    let c4  : i64 = 2097151 & (load4(&c[10..]) >> 4) as i64;
+    let c5  : i64 = 2097151 & (load3(&c[13..]) >> 1) as i64;
+    let c6  : i64 = 2097151 & (load4(&c[15..]) >> 6) as i64;
+    let c7  : i64 = 2097151 & (load3(&c[18..]) >> 3) as i64;
+    let c8  : i64 = 2097151 &  load3(&c[21..]) as i64;
+    let c9  : i64 = 2097151 & (load4(&c[23..]) >> 5) as i64;
+    let c10 : i64 = 2097151 & (load3(&c[26..]) >> 2) as i64;
+    let c11 : i64 =           (load4(&c[28..]) >> 7) as i64;
+    let mut s0 : i64;
+    let mut s1 : i64;
+    let mut s2 : i64;
+    let mut s3 : i64;
+    let mut s4 : i64;
+    let mut s5 : i64;
+    let mut s6 : i64;
+    let mut s7 : i64;
+    let mut s8 : i64;
+    let mut s9 : i64;
+    let mut s10 : i64;
+    let mut s11 : i64;
+    let mut s12 : i64;
+    let mut s13 : i64;
+    let mut s14 : i64;
+    let mut s15 : i64;
+    let mut s16 : i64;
+    let mut s17 : i64;
+    let mut s18 : i64;
+    let mut s19 : i64;
+    let mut s20 : i64;
+    let mut s21 : i64;
+    let mut s22 : i64;
+    let mut s23 : i64;
+    let mut carry0 : i64;
+    let mut carry1 : i64;
+    let mut carry2 : i64;
+    let mut carry3 : i64;
+    let mut carry4 : i64;
+    let mut carry5 : i64;
+    let mut carry6 : i64;
+    let mut carry7 : i64;
+    let mut carry8 : i64;
+    let mut carry9 : i64;
+    let mut carry10 : i64;
+    let mut carry11 : i64;
+    let mut carry12 : i64;
+    let mut carry13 : i64;
+    let mut carry14 : i64;
+    let mut carry15 : i64;
+    let mut carry16 : i64;
+    let     carry17 : i64;
+    let     carry18 : i64;
+    let     carry19 : i64;
+    let     carry20 : i64;
+    let     carry21 : i64;
+    let     carry22 : i64;
+  
+    s0 = c0 + a0 * b0;
+    s1 = c1 + a0 * b1 + a1 * b0;
+    s2 = c2 + a0 * b2 + a1 * b1 + a2 * b0;
+    s3 = c3 + a0 * b3 + a1 * b2 + a2 * b1 + a3 * b0;
+    s4 = c4 + a0 * b4 + a1 * b3 + a2 * b2 + a3 * b1 + a4 * b0;
+    s5 = c5 + a0 * b5 + a1 * b4 + a2 * b3 + a3 * b2 + a4 * b1 + a5 * b0;
+    s6 = c6 + a0 * b6 + a1 * b5 + a2 * b4 + a3 * b3 + a4 * b2 + a5 * b1 + a6 * b0;
+    s7 = c7 + a0 * b7 + a1 * b6 + a2 * b5 + a3 * b4 + a4 * b3 + a5 * b2 +
+         a6 * b1 + a7 * b0;
+    s8 = c8 + a0 * b8 + a1 * b7 + a2 * b6 + a3 * b5 + a4 * b4 + a5 * b3 +
+         a6 * b2 + a7 * b1 + a8 * b0;
+    s9 = c9 + a0 * b9 + a1 * b8 + a2 * b7 + a3 * b6 + a4 * b5 + a5 * b4 +
+         a6 * b3 + a7 * b2 + a8 * b1 + a9 * b0;
+    s10 = c10 + a0 * b10 + a1 * b9 + a2 * b8 + a3 * b7 + a4 * b6 + a5 * b5 +
+          a6 * b4 + a7 * b3 + a8 * b2 + a9 * b1 + a10 * b0;
+    s11 = c11 + a0 * b11 + a1 * b10 + a2 * b9 + a3 * b8 + a4 * b7 + a5 * b6 +
+          a6 * b5 + a7 * b4 + a8 * b3 + a9 * b2 + a10 * b1 + a11 * b0;
+    s12 = a1 * b11 + a2 * b10 + a3 * b9 + a4 * b8 + a5 * b7 + a6 * b6 + a7 * b5 +
+          a8 * b4 + a9 * b3 + a10 * b2 + a11 * b1;
+    s13 = a2 * b11 + a3 * b10 + a4 * b9 + a5 * b8 + a6 * b7 + a7 * b6 + a8 * b5 +
+          a9 * b4 + a10 * b3 + a11 * b2;
+    s14 = a3 * b11 + a4 * b10 + a5 * b9 + a6 * b8 + a7 * b7 + a8 * b6 + a9 * b5 +
+          a10 * b4 + a11 * b3;
+    s15 = a4 * b11 + a5 * b10 + a6 * b9 + a7 * b8 + a8 * b7 + a9 * b6 + a10 * b5 +
+          a11 * b4;
+    s16 = a5 * b11 + a6 * b10 + a7 * b9 + a8 * b8 + a9 * b7 + a10 * b6 + a11 * b5;
+    s17 = a6 * b11 + a7 * b10 + a8 * b9 + a9 * b8 + a10 * b7 + a11 * b6;
+    s18 = a7 * b11 + a8 * b10 + a9 * b9 + a10 * b8 + a11 * b7;
+    s19 = a8 * b11 + a9 * b10 + a10 * b9 + a11 * b8;
+    s20 = a9 * b11 + a10 * b10 + a11 * b9;
+    s21 = a10 * b11 + a11 * b10;
+    s22 = a11 * b11;
+    s23 = 0;
+  
+    carry0 = (s0 + (1 << 20)) >> 21;
+    s1 += carry0;
+    s0 -= carry0 << 21;
+    carry2 = (s2 + (1 << 20)) >> 21;
+    s3 += carry2;
+    s2 -= carry2 << 21;
+    carry4 = (s4 + (1 << 20)) >> 21;
+    s5 += carry4;
+    s4 -= carry4 << 21;
+    carry6 = (s6 + (1 << 20)) >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry8 = (s8 + (1 << 20)) >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry10 = (s10 + (1 << 20)) >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+    carry12 = (s12 + (1 << 20)) >> 21;
+    s13 += carry12;
+    s12 -= carry12 << 21;
+    carry14 = (s14 + (1 << 20)) >> 21;
+    s15 += carry14;
+    s14 -= carry14 << 21;
+    carry16 = (s16 + (1 << 20)) >> 21;
+    s17 += carry16;
+    s16 -= carry16 << 21;
+    carry18 = (s18 + (1 << 20)) >> 21;
+    s19 += carry18;
+    s18 -= carry18 << 21;
+    carry20 = (s20 + (1 << 20)) >> 21;
+    s21 += carry20;
+    s20 -= carry20 << 21;
+    carry22 = (s22 + (1 << 20)) >> 21;
+    s23 += carry22;
+    s22 -= carry22 << 21;
+  
+    carry1 = (s1 + (1 << 20)) >> 21;
+    s2 += carry1;
+    s1 -= carry1 << 21;
+    carry3 = (s3 + (1 << 20)) >> 21;
+    s4 += carry3;
+    s3 -= carry3 << 21;
+    carry5 = (s5 + (1 << 20)) >> 21;
+    s6 += carry5;
+    s5 -= carry5 << 21;
+    carry7 = (s7 + (1 << 20)) >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry9 = (s9 + (1 << 20)) >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry11 = (s11 + (1 << 20)) >> 21;
+    s12 += carry11;
+    s11 -= carry11 << 21;
+    carry13 = (s13 + (1 << 20)) >> 21;
+    s14 += carry13;
+    s13 -= carry13 << 21;
+    carry15 = (s15 + (1 << 20)) >> 21;
+    s16 += carry15;
+    s15 -= carry15 << 21;
+    carry17 = (s17 + (1 << 20)) >> 21;
+    s18 += carry17;
+    s17 -= carry17 << 21;
+    carry19 = (s19 + (1 << 20)) >> 21;
+    s20 += carry19;
+    s19 -= carry19 << 21;
+    carry21 = (s21 + (1 << 20)) >> 21;
+    s22 += carry21;
+    s21 -= carry21 << 21;
+  
+    s11 += s23 * 666643;
+    s12 += s23 * 470296;
+    s13 += s23 * 654183;
+    s14 -= s23 * 997805;
+    s15 += s23 * 136657;
+    s16 -= s23 * 683901;
+    //s23 = 0;
+  
+    s10 += s22 * 666643;
+    s11 += s22 * 470296;
+    s12 += s22 * 654183;
+    s13 -= s22 * 997805;
+    s14 += s22 * 136657;
+    s15 -= s22 * 683901;
+    //s22 = 0;
+  
+    s9 += s21 * 666643;
+    s10 += s21 * 470296;
+    s11 += s21 * 654183;
+    s12 -= s21 * 997805;
+    s13 += s21 * 136657;
+    s14 -= s21 * 683901;
+    //s21 = 0;
+  
+    s8 += s20 * 666643;
+    s9 += s20 * 470296;
+    s10 += s20 * 654183;
+    s11 -= s20 * 997805;
+    s12 += s20 * 136657;
+    s13 -= s20 * 683901;
+    //s20 = 0;
+  
+    s7 += s19 * 666643;
+    s8 += s19 * 470296;
+    s9 += s19 * 654183;
+    s10 -= s19 * 997805;
+    s11 += s19 * 136657;
+    s12 -= s19 * 683901;
+    //s19 = 0;
+  
+    s6 += s18 * 666643;
+    s7 += s18 * 470296;
+    s8 += s18 * 654183;
+    s9 -= s18 * 997805;
+    s10 += s18 * 136657;
+    s11 -= s18 * 683901;
+    //s18 = 0;
+  
+    carry6 = (s6 + (1 << 20)) >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry8 = (s8 + (1 << 20)) >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry10 = (s10 + (1 << 20)) >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+    carry12 = (s12 + (1 << 20)) >> 21;
+    s13 += carry12;
+    s12 -= carry12 << 21;
+    carry14 = (s14 + (1 << 20)) >> 21;
+    s15 += carry14;
+    s14 -= carry14 << 21;
+    carry16 = (s16 + (1 << 20)) >> 21;
+    s17 += carry16;
+    s16 -= carry16 << 21;
+  
+    carry7 = (s7 + (1 << 20)) >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry9 = (s9 + (1 << 20)) >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry11 = (s11 + (1 << 20)) >> 21;
+    s12 += carry11;
+    s11 -= carry11 << 21;
+    carry13 = (s13 + (1 << 20)) >> 21;
+    s14 += carry13;
+    s13 -= carry13 << 21;
+    carry15 = (s15 + (1 << 20)) >> 21;
+    s16 += carry15;
+    s15 -= carry15 << 21;
+  
+    s5 += s17 * 666643;
+    s6 += s17 * 470296;
+    s7 += s17 * 654183;
+    s8 -= s17 * 997805;
+    s9 += s17 * 136657;
+    s10 -= s17 * 683901;
+    //s17 = 0;
+  
+    s4 += s16 * 666643;
+    s5 += s16 * 470296;
+    s6 += s16 * 654183;
+    s7 -= s16 * 997805;
+    s8 += s16 * 136657;
+    s9 -= s16 * 683901;
+    //s16 = 0;
+  
+    s3 += s15 * 666643;
+    s4 += s15 * 470296;
+    s5 += s15 * 654183;
+    s6 -= s15 * 997805;
+    s7 += s15 * 136657;
+    s8 -= s15 * 683901;
+    //s15 = 0;
+  
+    s2 += s14 * 666643;
+    s3 += s14 * 470296;
+    s4 += s14 * 654183;
+    s5 -= s14 * 997805;
+    s6 += s14 * 136657;
+    s7 -= s14 * 683901;
+    //s14 = 0;
+  
+    s1 += s13 * 666643;
+    s2 += s13 * 470296;
+    s3 += s13 * 654183;
+    s4 -= s13 * 997805;
+    s5 += s13 * 136657;
+    s6 -= s13 * 683901;
+    //s13 = 0;
+  
+    s0 += s12 * 666643;
+    s1 += s12 * 470296;
+    s2 += s12 * 654183;
+    s3 -= s12 * 997805;
+    s4 += s12 * 136657;
+    s5 -= s12 * 683901;
+    s12 = 0;
+  
+    carry0 = (s0 + (1 << 20)) >> 21;
+    s1 += carry0;
+    s0 -= carry0 << 21;
+    carry2 = (s2 + (1 << 20)) >> 21;
+    s3 += carry2;
+    s2 -= carry2 << 21;
+    carry4 = (s4 + (1 << 20)) >> 21;
+    s5 += carry4;
+    s4 -= carry4 << 21;
+    carry6 = (s6 + (1 << 20)) >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry8 = (s8 + (1 << 20)) >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry10 = (s10 + (1 << 20)) >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+  
+    carry1 = (s1 + (1 << 20)) >> 21;
+    s2 += carry1;
+    s1 -= carry1 << 21;
+    carry3 = (s3 + (1 << 20)) >> 21;
+    s4 += carry3;
+    s3 -= carry3 << 21;
+    carry5 = (s5 + (1 << 20)) >> 21;
+    s6 += carry5;
+    s5 -= carry5 << 21;
+    carry7 = (s7 + (1 << 20)) >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry9 = (s9 + (1 << 20)) >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry11 = (s11 + (1 << 20)) >> 21;
+    s12 += carry11;
+    s11 -= carry11 << 21;
+  
+    s0 += s12 * 666643;
+    s1 += s12 * 470296;
+    s2 += s12 * 654183;
+    s3 -= s12 * 997805;
+    s4 += s12 * 136657;
+    s5 -= s12 * 683901;
+    s12 = 0;
+  
+    carry0 = s0 >> 21;
+    s1 += carry0;
+    s0 -= carry0 << 21;
+    carry1 = s1 >> 21;
+    s2 += carry1;
+    s1 -= carry1 << 21;
+    carry2 = s2 >> 21;
+    s3 += carry2;
+    s2 -= carry2 << 21;
+    carry3 = s3 >> 21;
+    s4 += carry3;
+    s3 -= carry3 << 21;
+    carry4 = s4 >> 21;
+    s5 += carry4;
+    s4 -= carry4 << 21;
+    carry5 = s5 >> 21;
+    s6 += carry5;
+    s5 -= carry5 << 21;
+    carry6 = s6 >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry7 = s7 >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry8 = s8 >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry9 = s9 >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry10 = s10 >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+    carry11 = s11 >> 21;
+    s12 += carry11;
+    s11 -= carry11 << 21;
+  
+    s0 += s12 * 666643;
+    s1 += s12 * 470296;
+    s2 += s12 * 654183;
+    s3 -= s12 * 997805;
+    s4 += s12 * 136657;
+    s5 -= s12 * 683901;
+    //s12 = 0;
+  
+    carry0 = s0 >> 21;
+    s1 += carry0;
+    s0 -= carry0 << 21;
+    carry1 = s1 >> 21;
+    s2 += carry1;
+    s1 -= carry1 << 21;
+    carry2 = s2 >> 21;
+    s3 += carry2;
+    s2 -= carry2 << 21;
+    carry3 = s3 >> 21;
+    s4 += carry3;
+    s3 -= carry3 << 21;
+    carry4 = s4 >> 21;
+    s5 += carry4;
+    s4 -= carry4 << 21;
+    carry5 = s5 >> 21;
+    s6 += carry5;
+    s5 -= carry5 << 21;
+    carry6 = s6 >> 21;
+    s7 += carry6;
+    s6 -= carry6 << 21;
+    carry7 = s7 >> 21;
+    s8 += carry7;
+    s7 -= carry7 << 21;
+    carry8 = s8 >> 21;
+    s9 += carry8;
+    s8 -= carry8 << 21;
+    carry9 = s9 >> 21;
+    s10 += carry9;
+    s9 -= carry9 << 21;
+    carry10 = s10 >> 21;
+    s11 += carry10;
+    s10 -= carry10 << 21;
+  
+    s[0] = (s0 >> 0) as u8;
+    s[1] = (s0 >> 8) as u8;
+    s[2] = ((s0 >> 16) | (s1 << 5)) as u8;
+    s[3] = (s1 >> 3) as u8;
+    s[4] = (s1 >> 11) as u8;
+    s[5] = ((s1 >> 19) | (s2 << 2)) as u8;
+    s[6] = (s2 >> 6) as u8;
+    s[7] = ((s2 >> 14) | (s3 << 7)) as u8;
+    s[8] = (s3 >> 1) as u8;
+    s[9] = (s3 >> 9) as u8;
+    s[10] = ((s3 >> 17) | (s4 << 4)) as u8;
+    s[11] = (s4 >> 4) as u8;
+    s[12] = (s4 >> 12) as u8;
+    s[13] = ((s4 >> 20) | (s5 << 1)) as u8;
+    s[14] = (s5 >> 7) as u8;
+    s[15] = ((s5 >> 15) | (s6 << 6)) as u8;
+    s[16] = (s6 >> 2) as u8;
+    s[17] = (s6 >> 10) as u8;
+    s[18] = ((s6 >> 18) | (s7 << 3)) as u8;
+    s[19] = (s7 >> 5) as u8;
+    s[20] = (s7 >> 13) as u8;
+    s[21] = (s8 >> 0) as u8;
+    s[22] = (s8 >> 8) as u8;
+    s[23] = ((s8 >> 16) | (s9 << 5)) as u8;
+    s[24] = (s9 >> 3) as u8;
+    s[25] = (s9 >> 11) as u8;
+    s[26] = ((s9 >> 19) | (s10 << 2)) as u8;
+    s[27] = (s10 >> 6) as u8;
+    s[28] = ((s10 >> 14) | (s11 << 7)) as u8;
+    s[29] = (s11 >> 1) as u8;
+    s[30] = (s11 >> 9) as u8;
+    s[31] = (s11 >> 17) as u8;
+}
+
+#[cfg(test)]
+#[test]
+fn muladd() {
+    let fname = "testdata/ed25519/muladd.test";
+    run_test(fname.to_string(), 4, |case| {
+        let (nega, abytes) = case.get("a").unwrap();
+        let (negb, bbytes) = case.get("b").unwrap();
+        let (negc, cbytes) = case.get("c").unwrap();
+        let (negd, dbytes) = case.get("d").unwrap();
+
+        assert!(!nega && !negb && !negc && !negd);
+        let mut mine = [0; 32];
+        x25519_sc_muladd(&mut mine, abytes, bbytes, cbytes);
+        for i in 0..32 {
+          assert_eq!(&mine[i], &dbytes[i]);
+        }
+    });
+}
+
+pub fn curve25519_scalar_mask(a: &mut [u8])
+{
+    assert_eq!(a.len(), 32);
+    a[0] &= 248;
+    a[31] &= 127;
+    a[31] |= 64;
+}
+

src/lib.rs

@@ -9,6 +9,7 @@
 //! that a new user should use, along with documentation regarding how and
 //! when they should use it, and examples. For now, it mostly just fowards
 //! off to more detailed modules. Help requested!
+extern crate base64;
 extern crate byteorder;
 extern crate chrono;
 extern crate cryptonum;
@@ -35,10 +36,29 @@ pub mod dsa;
 /// The `ecdsa` module provides bare-bones support for ECDSA signing,
 /// verification, and key generation.
 pub mod ecdsa;
+/// The `ed25519` provides signing and verification using ED25519.
+pub mod ed25519;
+/// The `ssh` module provides support for parsing OpenSSH-formatted SSH keys,
+/// both public and private.
+pub mod ssh;
 /// The `x509` module supports parsing and generating x.509 certificates, as
 /// used by TLS and others.
 pub mod x509;
 
+/// A generic trait for defining what a key pair looks like. This is useful
+/// in a couple places in which we want to define code regardless of the
+/// kind of key it is, but is unlikely to be hugely useful to users of the
+/// library.
+pub trait KeyPair {
+    /// The type of the public key of this pair.
+    type Public;
+    /// The type of the private key of this pair.
+    type Private;
+
+    /// Generate a key pair given the provided public and private keys.
+    fn new(pbl: Self::Public, prv: Self::Private) -> Self;
+}
+
 #[cfg(test)]
 mod testing;
 mod utils;

src/rsa/core.rs

@@ -1,7 +1,23 @@
+use cryptonum::unsigned::*;
 use num::bigint::BigUint;
 use rsa::errors::RSAError;
 use simple_asn1::{ASN1Block,ASN1DecodeErr};
 
+/// A valid key size for RSA keys, basically, and a (slightly annoying)
+/// trait that is used to tie these types to their Barrett value types.
+pub trait RSAMode {
+    type Barrett;
+}
+
+impl RSAMode for U512     { type Barrett = BarrettU512;   }
+impl RSAMode for U1024    { type Barrett = BarrettU1024;  }
+impl RSAMode for U2048    { type Barrett = BarrettU2048;  }
+impl RSAMode for U3072    { type Barrett = BarrettU3072;  }
+impl RSAMode for U4096    { type Barrett = BarrettU4096;  }
+impl RSAMode for U8192    { type Barrett = BarrettU8192;  }
+impl RSAMode for U15360   { type Barrett = BarrettU15360; }
+
+
 pub fn pkcs1_pad(ident: &[u8], hash: &[u8], keylen: usize) -> Vec<u8>
 {
     let mut idhash = Vec::new();

src/rsa/errors.rs

@@ -1,6 +1,8 @@
 use simple_asn1::ASN1DecodeErr;
 use rand;
 
+/// A bunch of errors that you can get generating, reading, or
+/// writing RSA keys.
 #[derive(Debug)]
 pub enum RSAError {
     BadMessageSize,

src/rsa/mod.rs

@@ -17,6 +17,39 @@
 //! Encryption and decryption are via the OAEP mechanism, as described in
 //! NIST documents.
 //!
+//! The following is an example of generating an RSA2048 key pair, then using
+//! it to sign, verify, encrypt, and decrypt some data.
+//! 
+//! ```rust
+//! extern crate cryptonum;
+//! extern crate sha2;
+//! 
+//! use simple_crypto::rsa::RSAKeyPair;
+//! use simple_crypto::rsa::SIGNING_HASH_SHA256;
+//! use simple_crypto::rsa::OAEPParams;
+//! use sha2::Sha256;
+//! use cryptonum::unsigned::U2048;
+//! 
+//! // Generate a new RSA with key size 2048. (This is an acceptable but
+//! // not great key size, but is a nice compromise given that this little
+//! // example runs as part of the test suite.)
+//! let mut rng = rand::rngs::OsRng::new().unwrap();
+//! let kp = RSAKeyPair::<U2048>::generate(&mut rng);
+//! 
+//! // Now that you have this key pair, you can sign and verify messages
+//! // using it. For example, to sign the vector [0,1,2,3,4] with SHA256
+//! // and then verify that signature, we would write: 
+//! let msg = vec![0,1,2,3,4];
+//! let sig = kp.private.sign(&SIGNING_HASH_SHA256, &msg);
+//! assert!( kp.public.verify(&SIGNING_HASH_SHA256, &msg, &sig) );
+//!
+//! // We can also use RSA public keys to encrypt data, which can then be
+//! // decrypted by the private key.
+//! let params = OAEPParams::<Sha256>::new(String::from("example!"));
+//! let cipher = kp.public.encrypt(&params, &msg).expect("Encryption error");
+//! let msg2 = kp.private.decrypt(&params, &cipher).expect("Decryption error");
+//! assert_eq!(msg, msg2);
+//! ```
 mod core;
 mod errors;
 mod oaep;
@@ -24,6 +57,7 @@ mod private;
 mod public;
 mod signing_hashes;
 
+pub use self::core::RSAMode;
 pub use self::errors::RSAError;
 pub use self::signing_hashes::{SigningHash,
                                SIGNING_HASH_NULL,
@@ -33,20 +67,16 @@ pub use self::signing_hashes::{SigningHash,
                                SIGNING_HASH_SHA384,
                                SIGNING_HASH_SHA512};
 pub use self::oaep::OAEPParams;
-pub use self::private::{RSAPrivate, RSAPrivateKey,
+pub use self::private::{RSAPrivate, RSAPrivateKey};
-                        RSA512Private, RSA1024Private, RSA2048Private,
+pub use self::public::{RSAPublic, RSAPublicKey};
-                        RSA3072Private, RSA4096Private, RSA8192Private,
-                        RSA15360Private};
-pub use self::public::{RSAPublic, RSAPublicKey,
-                       RSA512Public, RSA1024Public, RSA2048Public,
-                       RSA3072Public, RSA4096Public, RSA8192Public,
-                       RSA15360Public};
-
 use cryptonum::signed::{EGCD,ModInv};
 use cryptonum::unsigned::{CryptoNum,PrimeGen};
 use cryptonum::unsigned::{U256,U512,U1024,U1536,U2048,U3072,U4096,U7680,U8192,U15360};
 use rand::RngCore;
+#[cfg(test)]
+use std::fmt;
 use std::ops::Sub;
+use super::KeyPair;
 
 fn diff<T>(a: &T, b: &T) -> T
  where
@@ -60,38 +90,164 @@ fn diff<T>(a: &T, b: &T) -> T
     }
 }
 
+/// An RSA key pair containing keys of the given size; keeping them in the
+/// type means you'll never forget which one you have.
+/// 
+/// As an aside:
+///   * `U512` should only be used for testing
+///   * `U1024` should only be used to support old protocols or devices
+///   * `U2048` is probably your bare minimum
+///   * `U3072` is a very reasonable choice
+///   * **`U4096` is what you should use**
+///   * `U8192` is starting to get a bit silly (and slow)
+///   * `U15360` is for when you're using encryption to heat your house or server room
+pub struct RSAKeyPair<R: RSAMode> {
+    pub public:  RSAPublicKey<R>,
+    pub private: RSAPrivateKey<R>
+}
+
+/// A generic RSA key pair that is agnostic about its key size. It's not
+/// totally clear why this is useful, at this point.
+#[derive(PartialEq)]
+pub enum RSAPair {
+    R512(RSAPublicKey<U512>,     RSAPrivateKey<U512>),
+    R1024(RSAPublicKey<U1024>,   RSAPrivateKey<U1024>),
+    R2048(RSAPublicKey<U2048>,   RSAPrivateKey<U2048>),
+    R3072(RSAPublicKey<U3072>,   RSAPrivateKey<U3072>),
+    R4096(RSAPublicKey<U4096>,   RSAPrivateKey<U4096>),
+    R8192(RSAPublicKey<U8192>,   RSAPrivateKey<U8192>),
+    R15360(RSAPublicKey<U15360>, RSAPrivateKey<U15360>),
+}
+
+#[cfg(test)]
+impl fmt::Debug for RSAPair {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> 
+    {
+        match self {
+            RSAPair::R512(_,_) => f.write_str("512-bit RSA key pair"),
+            RSAPair::R1024(_,_) => f.write_str("1024-bit RSA key pair"),
+            RSAPair::R2048(_,_) => f.write_str("2048-bit RSA key pair"),
+            RSAPair::R3072(_,_) => f.write_str("3072-bit RSA key pair"),
+            RSAPair::R4096(_,_) => f.write_str("4096-bit RSA key pair"),
+            RSAPair::R8192(_,_) => f.write_str("8192-bit RSA key pair"),
+            RSAPair::R15360(_,_) => f.write_str("15360-bit RSA key pair"),
+        }
+    }
+}
+
+impl KeyPair for RSAPair {
+    type Public = RSAPublic;
+    type Private = RSAPrivate;
+
+    fn new(pu: RSAPublic, pr: RSAPrivate) -> RSAPair
+    {
+        match (pu, pr) {
+            (RSAPublic::Key512(pbl), RSAPrivate::Key512(prv)) =>
+                RSAPair::R512(pbl, prv),
+            (RSAPublic::Key1024(pbl), RSAPrivate::Key1024(prv)) =>
+                RSAPair::R1024(pbl, prv),
+            (RSAPublic::Key2048(pbl), RSAPrivate::Key2048(prv)) =>
+                RSAPair::R2048(pbl, prv),
+            (RSAPublic::Key3072(pbl), RSAPrivate::Key3072(prv)) =>
+                RSAPair::R3072(pbl, prv),
+            (RSAPublic::Key4096(pbl), RSAPrivate::Key4096(prv)) =>
+                RSAPair::R4096(pbl, prv),
+            (RSAPublic::Key8192(pbl), RSAPrivate::Key8192(prv)) =>
+                RSAPair::R8192(pbl, prv),
+            (RSAPublic::Key15360(pbl), RSAPrivate::Key15360(prv)) =>
+                RSAPair::R15360(pbl, prv),
+            _ =>
+                panic!("Unmatched public/private arguments to RSAPair::new()")
+        }
+    }
+}
+
+impl RSAPair {
+    pub fn sign(&self, signhash: &SigningHash, msg: &[u8]) -> Vec<u8>
+    {
+        match self {
+            RSAPair::R512(_,prv) => prv.sign(signhash, msg),
+            RSAPair::R1024(_,prv) => prv.sign(signhash, msg),
+            RSAPair::R2048(_,prv) => prv.sign(signhash, msg),
+            RSAPair::R3072(_,prv) => prv.sign(signhash, msg),
+            RSAPair::R4096(_,prv) => prv.sign(signhash, msg),
+            RSAPair::R8192(_,prv) => prv.sign(signhash, msg),
+            RSAPair::R15360(_,prv) => prv.sign(signhash, msg),
+        }
+    }
+    
+    pub fn verify(&self, signhash: &SigningHash, msg: &[u8], sig: &[u8]) -> bool
+    {
+        match self {
+            RSAPair::R512(pbl,_) => pbl.verify(signhash, msg, sig),
+            RSAPair::R1024(pbl,_) => pbl.verify(signhash, msg, sig),
+            RSAPair::R2048(pbl,_) => pbl.verify(signhash, msg, sig),
+            RSAPair::R3072(pbl,_) => pbl.verify(signhash, msg, sig),
+            RSAPair::R4096(pbl,_) => pbl.verify(signhash, msg, sig),
+            RSAPair::R8192(pbl,_) => pbl.verify(signhash, msg, sig),
+            RSAPair::R15360(pbl,_) => pbl.verify(signhash, msg, sig),
+        }
+    }
+
+    pub fn public(&self) -> RSAPublic
+    {
+        match self {
+            &RSAPair::R512(ref pbl,_)   => RSAPublic::Key512(pbl.clone()),
+            &RSAPair::R1024(ref pbl,_)  => RSAPublic::Key1024(pbl.clone()),
+            &RSAPair::R2048(ref pbl,_)  => RSAPublic::Key2048(pbl.clone()),
+            &RSAPair::R3072(ref pbl,_)  => RSAPublic::Key3072(pbl.clone()),
+            &RSAPair::R4096(ref pbl,_)  => RSAPublic::Key4096(pbl.clone()),
+            &RSAPair::R8192(ref pbl,_)  => RSAPublic::Key8192(pbl.clone()),
+            &RSAPair::R15360(ref pbl,_) => RSAPublic::Key15360(pbl.clone()),
+        }
+     }
+
+    pub fn private(&self) -> RSAPrivate
+    {
+        match self {
+            &RSAPair::R512(_,ref prv)   => RSAPrivate::Key512(prv.clone()),
+            &RSAPair::R1024(_,ref prv)  => RSAPrivate::Key1024(prv.clone()),
+            &RSAPair::R2048(_,ref prv)  => RSAPrivate::Key2048(prv.clone()),
+            &RSAPair::R3072(_,ref prv)  => RSAPrivate::Key3072(prv.clone()),
+            &RSAPair::R4096(_,ref prv)  => RSAPrivate::Key4096(prv.clone()),
+            &RSAPair::R8192(_,ref prv)  => RSAPrivate::Key8192(prv.clone()),
+            &RSAPair::R15360(_,ref prv) => RSAPrivate::Key15360(prv.clone()),
+        }
+     }
+}
+
 macro_rules! generate_rsa_pair
 {
-    ($pair: ident, $pub: ident, $priv: ident, $uint: ident, $half: ident, $iterations: expr) => {
+    ($uint: ident, $half: ident, $iterations: expr) => {
-        pub struct $pair {
+        impl KeyPair for RSAKeyPair<$uint> {
-            pub public: $pub,
+            type Public = RSAPublicKey<$uint>;
-            pub private: $priv
+            type Private = RSAPrivateKey<$uint>;
-        }
 
-        impl $pair {
+            fn new(pu: RSAPublicKey<$uint>, pr: RSAPrivateKey<$uint>) -> RSAKeyPair<$uint> {
-            pub fn new(pu: $pub, pr: $priv) -> $pair {
+                RSAKeyPair {
-                $pair {
                     public: pu,
                     private: pr
                 }
             }
+        }
 
-            pub fn generate<G>(rng: &mut G) -> $pair
+        impl RSAKeyPair<$uint> {
+            pub fn generate<G>(rng: &mut G) -> RSAKeyPair<$uint>
              where G: RngCore
             {
                 loop {
                     let ebase = 65537u32;
                     let e = $uint::from(ebase);
-                    let (p, q) = $pair::generate_pq(rng, &$half::from(ebase));
+                    let (p, q) = RSAKeyPair::<$uint>::generate_pq(rng, &$half::from(ebase));
                     let one = $half::from(1u32);
                     let pminus1 = &p - &one;
                     let qminus1 = &q - &one;
                     let phi = pminus1 * qminus1;
                     let n = &p * &q;
                     if let Some(d) = e.modinv(&phi) {
-                        let public = $pub::new(n.clone(), e);
+                        let public = RSAPublicKey::<$uint>::new(n.clone(), e);
-                        let private = $priv::new(n, d);
+                        let private = RSAPrivateKey::<$uint>::new(n, d);
-                        return $pair::new(public, private);
+                        return RSAKeyPair::<$uint>::new(public, private);
                     }
                 }
             }
@@ -129,13 +285,13 @@ macro_rules! generate_rsa_pair
     }
 }
 
-generate_rsa_pair!(RSA512KeyPair,   RSA512Public,   RSA512Private,   U512,   U256,  7);
+generate_rsa_pair!(U512,   U256,  7);
-generate_rsa_pair!(RSA1024KeyPair,  RSA1024Public,  RSA1024Private,  U1024,  U512,  7);
+generate_rsa_pair!(U1024,  U512,  7);
-generate_rsa_pair!(RSA2048KeyPair,  RSA2048Public,  RSA2048Private,  U2048,  U1024, 4);
+generate_rsa_pair!(U2048,  U1024, 4);
-generate_rsa_pair!(RSA3072KeyPair,  RSA3072Public,  RSA3072Private,  U3072,  U1536, 3);
+generate_rsa_pair!(U3072,  U1536, 3);
-generate_rsa_pair!(RSA4096KeyPair,  RSA4096Public,  RSA4096Private,  U4096,  U2048, 3);
+generate_rsa_pair!(U4096,  U2048, 3);
-generate_rsa_pair!(RSA8192KeyPair,  RSA8192Public,  RSA8192Private,  U8192,  U4096, 3);
+generate_rsa_pair!(U8192,  U4096, 3);
-generate_rsa_pair!(RSA15360KeyPair, RSA15360Public, RSA15360Private, U15360, U7680, 3);
+generate_rsa_pair!(U15360, U7680, 3);
 
 #[cfg(test)]
 mod generation {
@@ -143,15 +299,15 @@ mod generation {
     use std::fmt;
     use super::*;
 
-    impl Clone for RSA512KeyPair {
+    impl Clone for RSAKeyPair<U512> {
-        fn clone(&self) -> RSA512KeyPair {
+        fn clone(&self) -> RSAKeyPair<U512> {
-            RSA512KeyPair{
+            RSAKeyPair {
-                public: RSA512Public {
+                public: RSAPublicKey {
                     n: self.public.n.clone(),
                     nu: self.public.nu.clone(),
                     e: self.public.e.clone(),
                 },
-                private: RSA512Private {
+                private: RSAPrivateKey {
                     nu: self.private.nu.clone(),
                     d: self.private.d.clone()
                 }
@@ -159,7 +315,7 @@ mod generation {
         }
     }
 
-    impl fmt::Debug for RSA512KeyPair {
+    impl fmt::Debug for RSAKeyPair<U512> {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
             f.debug_struct("RSA512KeyPair")
              .field("n", &self.public.n)
@@ -169,14 +325,14 @@ mod generation {
         }
     }
 
-    impl Arbitrary for RSA512KeyPair {
+    impl Arbitrary for RSAKeyPair<U512> {
-        fn arbitrary<G: Gen>(g: &mut G) -> RSA512KeyPair {
+        fn arbitrary<G: Gen>(g: &mut G) -> RSAKeyPair<U512> {
-            RSA512KeyPair::generate(g)
+            RSAKeyPair::<U512>::generate(g)
         }
     }
 
     quickcheck! {
-        fn generate_and_sign(keypair: RSA512KeyPair, msg: Vec<u8>) -> bool {
+        fn generate_and_sign(keypair: RSAKeyPair<U512>, msg: Vec<u8>) -> bool {
             let sig = keypair.private.sign(&SIGNING_HASH_SHA256, &msg);
             keypair.public.verify(&SIGNING_HASH_SHA256, &msg, &sig)
         }

src/rsa/private.rs

@@ -1,65 +1,49 @@
 use cryptonum::unsigned::*;
 use digest::{Digest,FixedOutput};
-use rsa::core::{drop0s,pkcs1_pad,xor_vecs};
+use rsa::core::{RSAMode,drop0s,pkcs1_pad,xor_vecs};
 use rsa::errors::RSAError;
 use rsa::oaep::OAEPParams;
 use rsa::signing_hashes::SigningHash;
 
-pub trait RSAPrivateKey<N> {
+/// An RSA private key. Useful for signing messages and decrypting encrypted
-    /// Generate a new private key using the given modulus and private
+/// content.
-    /// exponent. You probably don't want to use this function directly
+#[derive(Clone,PartialEq)]
-    /// unless you're writing your own key generation routine or key
+pub struct RSAPrivateKey<R: RSAMode>
-    /// parsing library.
+{
-    fn new(n: N, d: N) -> Self;
+    pub(crate) nu: R::Barrett,
-
+    pub(crate) d:  R
-    /// Sign the given message with the given private key.
-    fn sign(&self, signhash: &SigningHash, msg: &[u8]) -> Vec<u8>;
-
-    /// Decrypt the provided message using the given OAEP parameters. As
-    /// mentioned in the comment for encryption, RSA decryption is really,
-    /// really slow. So if your plaintext is larger than about half the
-    /// bit size of the key, it's almost certainly a better idea to generate
-    /// a fresh symmetric encryption key, encrypt only the key with RSA, and
-    /// then encrypt the message with that key.
-    fn decrypt<H>(&self, oaep: &OAEPParams<H>, msg: &[u8])
-        -> Result<Vec<u8>,RSAError>
-     where H: Default + Digest + FixedOutput;
 }
 
+/// A generic RSA private key which is agnostic to its key size.
+#[derive(Clone,PartialEq)]
 pub enum RSAPrivate {
-    Key512(RSA512Private),
+    Key512(RSAPrivateKey<U512>),
-    Key1024(RSA1024Private),
+    Key1024(RSAPrivateKey<U1024>),
-    Key2048(RSA2048Private),
+    Key2048(RSAPrivateKey<U2048>),
-    Key3072(RSA3072Private),
+    Key3072(RSAPrivateKey<U3072>),
-    Key4096(RSA4096Private),
+    Key4096(RSAPrivateKey<U4096>),
-    Key8192(RSA8192Private),
+    Key8192(RSAPrivateKey<U8192>),
-    Key15360(RSA15360Private)
+    Key15360(RSAPrivateKey<U15360>)
 }
 
-// fn print_vector(name: &'static str, bytes: &[u8])
-// {
-//     print!("{}: (length {}) ", name, bytes.len());
-//     for x in bytes.iter() {
-//         print!("{:02X}", *x);
-//     }
-//     println!("");
-// }
-
 macro_rules! generate_rsa_private
 {
-    ($rsa: ident, $num: ident, $bar: ident, $size: expr) => {
+    ($num: ident, $bar: ident, $size: expr) => {
-        pub struct $rsa {
+        impl RSAPrivateKey<$num> {
-            pub(crate) nu: $bar,
+            /// Generate a new private key with the given modulus and private
-            pub(crate) d:  $num
+            /// number (`d`). This operation actually does a bit of computation
-        }
+            /// under the hood, in order to speed up future ones, so you might
-
+            /// want to strongly consider sharing rather than multiple
-        impl RSAPrivateKey<$num> for $rsa {
+            /// instantiation. But you do you.
-            fn new(n: $num, d: $num) -> $rsa {
+            pub fn new(n: $num, d: $num) -> RSAPrivateKey<$num> {
                 let nu = $bar::new(n.clone());
-                $rsa { nu: nu, d: d }
+                RSAPrivateKey{ nu: nu, d: d }
             }
 
-            fn sign(&self, signhash: &SigningHash, msg: &[u8])
+            /// Sign the given message with the given SigningHash, returning
+            /// the signature. This uses a deterministic PKCS1 method for
+            /// signing messages, so no RNG required.
+            pub fn sign(&self, signhash: &SigningHash, msg: &[u8])
                 -> Vec<u8>
             {
                 let hash = (signhash.run)(msg);
@@ -70,7 +54,14 @@ macro_rules! generate_rsa_private
                 sig
             }
 
-            fn decrypt<H>(&self, oaep: &OAEPParams<H>, msg: &[u8])
+            /// Decrypted the provided encrypted blob using the given
+            /// parameters. This does standard RSA OAEP decryption, which is
+            /// rather slow. If you have a choice, you should probably do
+            /// something clever, like only use this encryption/decryption
+            /// method to encrypt/decrypt a shared symmetric key, like an
+            /// AES key. That way, you only do this operation (which is
+            /// SO SLOW) for a relatively small amount of data.
+            pub fn decrypt<H>(&self, oaep: &OAEPParams<H>, msg: &[u8])
                 -> Result<Vec<u8>,RSAError>
              where H: Default + Digest + FixedOutput
             {
@@ -83,9 +74,7 @@ macro_rules! generate_rsa_private
 
                 Ok(res)
             }
-        }
 
-        impl $rsa {
             fn sp1(&self, m: &$num) -> $num {
                 m.modexp(&self.d, &self.nu)
             }
@@ -148,17 +137,87 @@ macro_rules! generate_rsa_private
     }
 }
 
-generate_rsa_private!(RSA512Private,   U512,   BarrettU512,   512);
+generate_rsa_private!(U512,   BarrettU512,   512);
-generate_rsa_private!(RSA1024Private,  U1024,  BarrettU1024,  1024);
+generate_rsa_private!(U1024,  BarrettU1024,  1024);
-generate_rsa_private!(RSA2048Private,  U2048,  BarrettU2048,  2048);
+generate_rsa_private!(U2048,  BarrettU2048,  2048);
-generate_rsa_private!(RSA3072Private,  U3072,  BarrettU3072,  3072);
+generate_rsa_private!(U3072,  BarrettU3072,  3072);
-generate_rsa_private!(RSA4096Private,  U4096,  BarrettU4096,  4096);
+generate_rsa_private!(U4096,  BarrettU4096,  4096);
-generate_rsa_private!(RSA8192Private,  U8192,  BarrettU8192,  8192);
+generate_rsa_private!(U8192,  BarrettU8192,  8192);
-generate_rsa_private!(RSA15360Private, U15360, BarrettU15360, 15360);
+generate_rsa_private!(U15360, BarrettU15360, 15360);
+
+#[cfg(test)]
+macro_rules! sign_test_body {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
+        let fname = format!("testdata/rsa/sign{}.test", $size);
+        run_test(fname.to_string(), 7, |case| {
+            let (neg0, dbytes) = case.get("d").unwrap();
+            let (neg1, nbytes) = case.get("n").unwrap();
+            let (neg2, hbytes) = case.get("h").unwrap();
+            let (neg3, mbytes) = case.get("m").unwrap();
+            let (neg4, sbytes) = case.get("s").unwrap();
+            let (neg5, ubytes) = case.get("u").unwrap();
+            let (neg6, kbytes) = case.get("k").unwrap();
+
+            assert!(!neg0&&!neg1&&!neg2&&!neg3&&!neg4&&!neg5&&!neg6);
+            let n = $num64::from_bytes(nbytes);
+            let nu = $num64::from_bytes(ubytes);
+            let bigk = $num::from_bytes(kbytes);
+            let k = usize::from(bigk);
+            let d = $num::from_bytes(dbytes);
+            let sighash = match usize::from($num::from_bytes(hbytes)) {
+                            224 => &SIGNING_HASH_SHA224,
+                            256 => &SIGNING_HASH_SHA256,
+                            384 => &SIGNING_HASH_SHA384,
+                            512 => &SIGNING_HASH_SHA512,
+                            x     => panic!("Bad signing hash: {}", x)
+                          };
+            let privkey = RSAPrivateKey{ nu: $bar::from_components(k, n.clone(), nu), d: d };
+            let sig = privkey.sign(sighash, &mbytes);
+            assert_eq!(*sbytes, sig);
+        });
+    };
+}
+
+#[cfg(test)]
+macro_rules! decrypt_test_body {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
+        let fname = format!("testdata/rsa/encrypt{}.test", $size);
+        run_test(fname.to_string(), 9, |case| {
+            let (neg0, nbytes) = case.get("n").unwrap();
+            let (neg1, hbytes) = case.get("h").unwrap();
+            let (neg2, mbytes) = case.get("m").unwrap();
+            let (neg3, _bytes) = case.get("e").unwrap();
+            let (neg4, ubytes) = case.get("u").unwrap();
+            let (neg5, kbytes) = case.get("k").unwrap();
+            let (neg6, dbytes) = case.get("d").unwrap();
+            let (neg7, lbytes) = case.get("l").unwrap();
+            let (neg8, cbytes) = case.get("c").unwrap();
+
+            assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5 && !neg6 && !neg7 && !neg8);
+            let n = $num::from_bytes(nbytes);
+            let n64 = $num64::from(&n);
+            let nu = $num64::from_bytes(ubytes);
+            let bigk = $num::from_bytes(kbytes);
+            let k = usize::from(bigk);
+            let d = $num::from_bytes(dbytes);
+            let nu = $bar::from_components(k, n64, nu);
+            let privkey = RSAPrivateKey{ nu: nu, d: d };
+            let lstr = String::from_utf8(lbytes.clone()).unwrap();
+            let message = match usize::from($num::from_bytes(hbytes)) {
+                224 => privkey.decrypt(&OAEPParams::<Sha224>::new(lstr), &cbytes),
+                256 => privkey.decrypt(&OAEPParams::<Sha256>::new(lstr), &cbytes),
+                384 => privkey.decrypt(&OAEPParams::<Sha384>::new(lstr), &cbytes),
+                512 => privkey.decrypt(&OAEPParams::<Sha512>::new(lstr), &cbytes),
+                x   => panic!("Unknown hash number: {}", x)
+            };
+            assert!(message.is_ok());
+            assert_eq!(mbytes, &message.unwrap());
+        });
+     };
+}
 
 macro_rules! generate_tests {
-    ( $( ($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) ),* ) => {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
-        $(
         #[cfg(test)]
         #[allow(non_snake_case)]
         mod $mod {
@@ -166,108 +225,48 @@ macro_rules! generate_tests {
             use super::*;
             use testing::run_test;
             use rsa::signing_hashes::*;
-            use sha1::Sha1;
             use sha2::{Sha224,Sha256,Sha384,Sha512};
 
             #[test]
             fn sign() {
-                let fname = format!("tests/rsa/rsa{}.test", $size);
+                sign_test_body!($mod, $num, $bar, $num64, $size);
-                run_test(fname.to_string(), 8, |case| {
-                    let (neg0, dbytes) = case.get("d").unwrap();
-                    let (neg1, nbytes) = case.get("n").unwrap();
-                    let (neg2, hbytes) = case.get("h").unwrap();
-                    let (neg3, mbytes) = case.get("m").unwrap();
-                    let (neg4, sbytes) = case.get("s").unwrap();
-                    let (neg5, ubytes) = case.get("u").unwrap();
-                    let (neg6, kbytes) = case.get("k").unwrap();
-
-                    assert!(!neg0&&!neg1&&!neg2&&!neg3&&!neg4&&!neg5&&!neg6);
-                    let n = $num64::from_bytes(nbytes);
-                    let nu = $num64::from_bytes(ubytes);
-                    let bigk = $num::from_bytes(kbytes);
-                    let k = usize::from(bigk);
-                    let d = $num::from_bytes(dbytes);
-                    let privkey = $rsa{ nu: $bar::from_components(k, n, nu), d: d };
-                    let hashnum = ((hbytes[0] as u16)<<8) + (hbytes[1] as u16);
-                    let sighash = match hashnum {
-                                    0x160 => &SIGNING_HASH_SHA1,
-                                    0x224 => &SIGNING_HASH_SHA224,
-                                    0x256 => &SIGNING_HASH_SHA256,
-                                    0x384 => &SIGNING_HASH_SHA384,
-                                    0x512 => &SIGNING_HASH_SHA512,
-                                    _     => panic!("Bad signing hash: {}", hashnum)
-                                  };
-                    let sig = privkey.sign(sighash, &mbytes);
-                    assert_eq!(sig, *sbytes);
-                });
             }
 
             #[test]
             fn decrypt() {
-                let fname = format!("tests/rsa/rsa{}.test", $size);
+                decrypt_test_body!($mod, $num, $bar, $num64, $size);
-                run_test(fname.to_string(), 8, |case| {
+            }
-                    let (neg0, dbytes) = case.get("d").unwrap();
+        }
-                    let (neg1, nbytes) = case.get("n").unwrap();
+    };
-                    let (neg2, hbytes) = case.get("h").unwrap();
+    (ignore $mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
-                    let (neg3, mbytes) = case.get("m").unwrap();
+        #[cfg(test)]
-                    let (neg4, cbytes) = case.get("c").unwrap();
+        #[allow(non_snake_case)]
-                    let (neg5, ubytes) = case.get("u").unwrap();
+        mod $mod {
-                    let (neg6, kbytes) = case.get("k").unwrap();
+            use cryptonum::unsigned::Decoder;
-
+            use super::*;
-                    assert!(!neg0&&!neg1&&!neg2&&!neg3&&!neg4&&!neg5&&!neg6);
+            use testing::run_test;
-                    let n = $num64::from_bytes(nbytes);
+            use rsa::signing_hashes::*;
-                    let nu = $num64::from_bytes(ubytes);
+            use sha2::{Sha224,Sha256,Sha384,Sha512};
-                    let bigk = $num::from_bytes(kbytes);
+
-                    let k = usize::from(bigk);
+            #[ignore]
-                    let d = $num::from_bytes(dbytes);
+            #[test]
-                    let privkey = $rsa{ nu: $bar::from_components(k, n, nu), d: d };
+            fn sign() {
-                    let hashnum = ((hbytes[0] as u16)<<8) + (hbytes[1] as u16);
+                sign_test_body!($mod, $num, $bar, $num64, $size);
-                    let empty = "".to_string();
+            }
-                    match hashnum {
+
-                        0x160 => {
+            #[ignore]
-                            let oaep = OAEPParams::<Sha1>::new(empty);
+            #[test]
-                            let plain = privkey.decrypt(&oaep, &cbytes);
+            fn decrypt() {
-                            assert!(plain.is_ok());
+                decrypt_test_body!($mod, $num, $bar, $num64, $size);
-                            assert_eq!(*mbytes, plain.unwrap());
-                        }
-                        0x224 =>{
-                            let oaep = OAEPParams::<Sha224>::new(empty);
-                            let plain = privkey.decrypt(&oaep, &cbytes);
-                            assert!(plain.is_ok());
-                            assert_eq!(*mbytes, plain.unwrap());
-                        }
-                        0x256 => {
-                            let oaep = OAEPParams::<Sha256>::new(empty);
-                            let plain = privkey.decrypt(&oaep, &cbytes);
-                            assert!(plain.is_ok());
-                            assert_eq!(*mbytes, plain.unwrap());
-                        }
-                        0x384 => {
-                            let oaep = OAEPParams::<Sha384>::new(empty);
-                            let plain = privkey.decrypt(&oaep, &cbytes);
-                            assert!(plain.is_ok());
-                            assert_eq!(*mbytes, plain.unwrap());
-                        }
-                        0x512 => {
-                            let oaep = OAEPParams::<Sha512>::new(empty);
-                            let plain = privkey.decrypt(&oaep, &cbytes);
-                            assert!(plain.is_ok());
-                            assert_eq!(*mbytes, plain.unwrap());
-                        }
-                        _     => panic!("Bad signing hash: {}", hashnum)
-                    };
-                });
             }
         }
-        )*
     }
 }
 
-generate_tests!( (RSA512,   RSA512Private,   U512,   BarrettU512,   U576,   512),
+generate_tests!(       RSA512,   U512,   BarrettU512,   U576,   512);
-                 (RSA1024,  RSA1024Private,  U1024,  BarrettU1024,  U1088,  1024),
+generate_tests!(       RSA1024,  U1024,  BarrettU1024,  U1088,  1024);
-                 (RSA2048,  RSA2048Private,  U2048,  BarrettU2048,  U2112,  2048)
+generate_tests!(       RSA2048,  U2048,  BarrettU2048,  U2112,  2048);
-//                 (RSA3072,  RSA3072Private,  U3072,  BarrettU3072,  U3136,  3072),
+generate_tests!(       RSA3072,  U3072,  BarrettU3072,  U3136,  3072);
-//                 (RSA4096,  RSA4096Private,  U4096,  BarrettU4096,  U4160,  4096),
+generate_tests!(       RSA4096,  U4096,  BarrettU4096,  U4160,  4096);
-//                 (RSA8192,  RSA8192Private,  U8192,  BarrettU8192,  U8256,  8192),
+generate_tests!(ignore RSA8192,  U8192,  BarrettU8192,  U8256,  8192);
-//                 (RSA15360, RSA15360Private, U15360, BarrettU15360, U15424, 15360)
+generate_tests!(ignore RSA15360, U15360, BarrettU15360, U15424, 15360);
-               );

src/rsa/public.rs

@@ -2,7 +2,7 @@ use cryptonum::unsigned::*;
 use digest::{Digest,FixedOutput};
 use rand::Rng;
 use rand::rngs::OsRng;
-use rsa::core::{decode_biguint,pkcs1_pad,xor_vecs};
+use rsa::core::{RSAMode,decode_biguint,pkcs1_pad,xor_vecs};
 use rsa::errors::RSAError;
 use rsa::oaep::OAEPParams;
 use rsa::signing_hashes::SigningHash;
@@ -12,65 +12,31 @@ use simple_asn1::{ASN1Block,ASN1DecodeErr,ASN1EncodeErr,
 use std::fmt;
 use utils::TranslateNums;
 
-pub trait RSAPublicKey<N> {
+/// An RSA public key. Useful for verifying signatures or encrypting data to
-    /// Generate a new public key pair for the given modulus and
+/// send to the private key holder.
-    /// exponent. You should probably not call this directly unless
+#[derive(Clone,PartialEq)]
-    /// you're writing a key generation function or writing your own
+pub struct RSAPublicKey<R: RSAMode> {
-    /// public key parser.
+    pub(crate) n:  R,
-    fn new(n: N, e: N) -> Self;
+    pub(crate) nu: R::Barrett,
-
+    pub(crate) e:  R 
-    /// Verify that the provided signature is valid; that the private
-    /// key associated with this public key sent exactly this message.
-    /// The hash used here must exactly match the hash used to sign
-    /// the message, including its ASN.1 metadata.
-    fn verify(&self, signhash: &SigningHash, msg: &[u8], sig: &[u8]) -> bool;
-
-    /// Encrypt the message with a hash function, given the appropriate
-    /// label. Please note that RSA encryption is not particularly fast,
-    /// and decryption is very slow indeed. Thus, most crypto systems that
-    /// need asymmetric encryption should generate a symmetric key, encrypt
-    /// that key with RSA encryption, and then encrypt the actual message
-    /// with that symmetric key.
-    ///
-    /// In this variant of the function, we use an explicit random number
-    /// generator, just in case you have one you really like. It better be
-    /// cryptographically strong, though, as some of the padding protections
-    /// are relying on it.
-    fn encrypt_rng<G,H>(&self, g: &mut G, oaep: &OAEPParams<H>, msg: &[u8])
-        -> Result<Vec<u8>,RSAError>
-     where
-      G: Rng,
-      H: Default + Digest + FixedOutput;
-
-    /// Encrypt the message with a hash function, given the appropriate
-    /// label. Please note that RSA encryption is not particularly fast,
-    /// and decryption is very slow indeed. Thus, most crypto systems that
-    /// need asymmetric encryption should generate a symmetric key, encrypt
-    /// that key with RSA encryption, and then encrypt the actual message
-    /// with that symmetric key.
-    ///
-    /// This variant will just use the system RNG for its randomness.
-    fn encrypt<H>(&self,oaep:&OAEPParams<H>,msg:&[u8])
-        -> Result<Vec<u8>,RSAError>
-     where
-      H: Default + Digest + FixedOutput
-    {
-        let mut g = OsRng::new()?;
-        self.encrypt_rng(&mut g, oaep, msg)
-    }
 }
 
+/// A generic private key that is agnostic to the key size.
+#[derive(Clone,PartialEq)]
 pub enum RSAPublic {
-    Key512(RSA512Public),
+    Key512(  RSAPublicKey<U512>),
-    Key1024(RSA1024Public),
+    Key1024( RSAPublicKey<U1024>),
-    Key2048(RSA2048Public),
+    Key2048( RSAPublicKey<U2048>),
-    Key3072(RSA3072Public),
+    Key3072( RSAPublicKey<U3072>),
-    Key4096(RSA4096Public),
+    Key4096( RSAPublicKey<U4096>),
-    Key8192(RSA8192Public),
+    Key8192( RSAPublicKey<U8192>),
-    Key15360(RSA15360Public)
+    Key15360(RSAPublicKey<U15360>)
 }
 
 impl RSAPublic {
+    /// Verify that the given signature is for the given message, passing
+    /// in the same signing arguments used to sign the message in the
+    /// first place.
     pub fn verify(&self, signhash: &SigningHash, msg: &[u8], sig: &[u8]) -> bool
     {
         match self {
@@ -102,8 +68,6 @@ impl FromASN1 for RSAPublic {
                 let nsize = n.bits();
                 let mut rsa_size = 512;
 
-                println!("n': {:X}", n);
-                println!("nsize: {}", nsize);
                 while rsa_size < nsize {
                     rsa_size = rsa_size + 256;
                 }
@@ -111,43 +75,43 @@ impl FromASN1 for RSAPublic {
                     512    => {
                         let n2 = U512::from_num(&n).ok_or(RSAError::InvalidKey)?;
                         let e2 = U512::from_num(&e).ok_or(RSAError::InvalidKey)?;
-                        let res = RSA512Public::new(n2, e2);
+                        let res = RSAPublicKey::<U512>::new(n2, e2);
                         Ok((RSAPublic::Key512(res), rest))
                     }
                     1024    => {
                         let n2 = U1024::from_num(&n).ok_or(RSAError::InvalidKey)?;
                         let e2 = U1024::from_num(&e).ok_or(RSAError::InvalidKey)?;
-                        let res = RSA1024Public::new(n2, e2);
+                        let res = RSAPublicKey::<U1024>::new(n2, e2);
                         Ok((RSAPublic::Key1024(res), rest))
                     }
                     2048    => {
                         let n2 = U2048::from_num(&n).ok_or(RSAError::InvalidKey)?;
                         let e2 = U2048::from_num(&e).ok_or(RSAError::InvalidKey)?;
-                        let res = RSA2048Public::new(n2, e2);
+                        let res = RSAPublicKey::<U2048>::new(n2, e2);
                         Ok((RSAPublic::Key2048(res), rest))
                     }
                     3072    => {
                         let n2 = U3072::from_num(&n).ok_or(RSAError::InvalidKey)?;
                         let e2 = U3072::from_num(&e).ok_or(RSAError::InvalidKey)?;
-                        let res = RSA3072Public::new(n2, e2);
+                        let res = RSAPublicKey::<U3072>::new(n2, e2);
                         Ok((RSAPublic::Key3072(res), rest))
                     }
                     4096    => {
                         let n2 = U4096::from_num(&n).ok_or(RSAError::InvalidKey)?;
                         let e2 = U4096::from_num(&e).ok_or(RSAError::InvalidKey)?;
-                        let res = RSA4096Public::new(n2, e2);
+                        let res = RSAPublicKey::<U4096>::new(n2, e2);
                         Ok((RSAPublic::Key4096(res), rest))
                     }
                     8192    => {
                         let n2 = U8192::from_num(&n).ok_or(RSAError::InvalidKey)?;
                         let e2 = U8192::from_num(&e).ok_or(RSAError::InvalidKey)?;
-                        let res = RSA8192Public::new(n2, e2);
+                        let res = RSAPublicKey::<U8192>::new(n2, e2);
                         Ok((RSAPublic::Key8192(res), rest))
                     }
                     15360    => {
                         let n2 = U15360::from_num(&n).ok_or(RSAError::InvalidKey)?;
                         let e2 = U15360::from_num(&e).ok_or(RSAError::InvalidKey)?;
-                        let res = RSA15360Public::new(n2, e2);
+                        let res = RSAPublicKey::<U15360>::new(n2, e2);
                         Ok((RSAPublic::Key15360(res), rest))
                     }
                     _      =>
@@ -178,32 +142,39 @@ impl ToASN1 for RSAPublic {
     }
 }
 
-// fn print_vector(name: &'static str, bytes: &[u8])
+#[cfg(test)]
-// {
+impl fmt::Debug for RSAPublic {
-//     print!("{}: (length {}) ", name, bytes.len());
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-//     for x in bytes.iter() {
+        match self {
-//         print!("{:02X}", *x);
+            RSAPublic::Key512(x)   => write!(fmt, "RSA:{:?}", x),
-//     }
+            RSAPublic::Key1024(x)  => write!(fmt, "RSA:{:?}", x),
-//     println!("");
+            RSAPublic::Key2048(x)  => write!(fmt, "RSA:{:?}", x),
-// }
+            RSAPublic::Key3072(x)  => write!(fmt, "RSA:{:?}", x),
-
+            RSAPublic::Key4096(x)  => write!(fmt, "RSA:{:?}", x),
+            RSAPublic::Key8192(x)  => write!(fmt, "RSA:{:?}", x),
+            RSAPublic::Key15360(x) => write!(fmt, "RSA:{:?}", x)
+        }
+    }
+}
+ 
 macro_rules! generate_rsa_public
 {
-    ($rsa: ident, $num: ident, $bar: ident, $var: ident, $size: expr) => {
+    ($num: ident, $bar: ident, $var: ident, $size: expr) => {
-        #[derive(PartialEq)]
+        impl RSAPublicKey<$num> {
-        pub struct $rsa {
+            /// Generate a new public key pair for the given modulus and
-            pub(crate) n:  $num,
+            /// exponent. You should probably not call this directly unless
-            pub(crate) nu: $bar,
+            /// you're writing a key generation function or writing your own
-            pub(crate) e:  $num
+            /// public key parser.
-        }
+            pub fn new(n: $num, e: $num) -> RSAPublicKey<$num> {
-
-        impl RSAPublicKey<$num> for $rsa {
-            fn new(n: $num, e: $num) -> $rsa {
                 let nu = $bar::new(n.clone());
-                $rsa { n: n, nu: nu, e: e }
+                RSAPublicKey{ n: n, nu: nu, e: e }
             }
 
-            fn verify(&self, signhash: &SigningHash, msg: &[u8], sig: &[u8])
+            /// Verify that the provided signature is valid; that the private
+            /// key associated with this public key sent exactly this message.
+            /// The hash used here must exactly match the hash used to sign
+            /// the message, including its ASN.1 metadata.
+            pub fn verify(&self, signhash: &SigningHash, msg: &[u8], sig: &[u8])
                 -> bool
             {
                 let hash: Vec<u8> = (signhash.run)(msg);
@@ -214,7 +185,18 @@ macro_rules! generate_rsa_public
                 em == em_
             }
 
-            fn encrypt_rng<G,H>(&self,g: &mut G,oaep: &OAEPParams<H>,msg: &[u8])
+            /// Encrypt the message with a hash function, given the appropriate
+            /// label. Please note that RSA encryption is not particularly fast,
+            /// and decryption is very slow indeed. Thus, most crypto systems that
+            /// need asymmetric encryption should generate a symmetric key, encrypt
+            /// that key with RSA encryption, and then encrypt the actual message
+            /// with that symmetric key.
+            ///
+            /// In this variant of the function, we use an explicit random number
+            /// generator, just in case you have one you really like. It better be
+            /// cryptographically strong, though, as some of the padding protections
+            /// are relying on it.
+            pub fn encrypt_rng<G,H>(&self,g: &mut G,oaep: &OAEPParams<H>,msg: &[u8])
                 -> Result<Vec<u8>,RSAError>
              where
               G: Rng,
@@ -233,9 +215,24 @@ macro_rules! generate_rsa_public
 
                 Ok(res)
             }
-        }
 
-        impl $rsa {
+            /// Encrypt the message with a hash function, given the appropriate
+            /// label. Please note that RSA encryption is not particularly fast,
+            /// and decryption is very slow indeed. Thus, most crypto systems that
+            /// need asymmetric encryption should generate a symmetric key, encrypt
+            /// that key with RSA encryption, and then encrypt the actual message
+            /// with that symmetric key.
+            ///
+            /// This variant will just use the system RNG for its randomness.
+            pub fn encrypt<H>(&self,oaep:&OAEPParams<H>,msg:&[u8])
+                -> Result<Vec<u8>,RSAError>
+             where
+              H: Default + Digest + FixedOutput
+            {
+                let mut g = OsRng::new()?;
+                self.encrypt_rng(&mut g, oaep, msg)
+            }
+
             fn vp1(&self, s: &$num) -> $num {
                 s.modexp(&self.e, &self.nu)
             }
@@ -294,11 +291,11 @@ macro_rules! generate_rsa_public
             }
         }
 
-        impl FromASN1 for $rsa {
+        impl FromASN1 for RSAPublicKey<$num> {
             type Error = RSAError;
 
             fn from_asn1(bs: &[ASN1Block])
-                -> Result<($rsa,&[ASN1Block]),RSAError>
+                -> Result<(RSAPublicKey<$num>,&[ASN1Block]),RSAError>
             {
                 let (core, rest) = RSAPublic::from_asn1(bs)?;
 
@@ -309,7 +306,7 @@ macro_rules! generate_rsa_public
             }
         }
 
-        impl ToASN1 for $rsa {
+        impl ToASN1 for RSAPublicKey<$num> {
             type Error = ASN1EncodeErr;
 
             fn to_asn1_class(&self, c: ASN1Class)
@@ -325,7 +322,7 @@ macro_rules! generate_rsa_public
         }
 
         #[cfg(test)]
-        impl fmt::Debug for $rsa {
+        impl fmt::Debug for RSAPublicKey<$num> {
             fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
                 fmt.debug_struct(stringify!($rsa))
                    .field("n", &self.n)
@@ -337,121 +334,195 @@ macro_rules! generate_rsa_public
     }
 }
 
-generate_rsa_public!(RSA512Public,   U512,   BarrettU512,   Key512,   512);
+generate_rsa_public!(U512,   BarrettU512,   Key512,   512);
-generate_rsa_public!(RSA1024Public,  U1024,  BarrettU1024,  Key1024,  1024);
+generate_rsa_public!(U1024,  BarrettU1024,  Key1024,  1024);
-generate_rsa_public!(RSA2048Public,  U2048,  BarrettU2048,  Key2048,  2048);
+generate_rsa_public!(U2048,  BarrettU2048,  Key2048,  2048);
-generate_rsa_public!(RSA3072Public,  U3072,  BarrettU3072,  Key3072,  3072);
+generate_rsa_public!(U3072,  BarrettU3072,  Key3072,  3072);
-generate_rsa_public!(RSA4096Public,  U4096,  BarrettU4096,  Key4096,  4096);
+generate_rsa_public!(U4096,  BarrettU4096,  Key4096,  4096);
-generate_rsa_public!(RSA8192Public,  U8192,  BarrettU8192,  Key8192,  8192);
+generate_rsa_public!(U8192,  BarrettU8192,  Key8192,  8192);
-generate_rsa_public!(RSA15360Public, U15360, BarrettU15360, Key15360, 15360);
+generate_rsa_public!(U15360, BarrettU15360, Key15360, 15360);
+
+#[cfg(test)]
+macro_rules! new_test_body {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
+        let fname = format!("testdata/rsa/sign{}.test", $size);
+        run_test(fname.to_string(), 7, |case| {
+            let (neg0, nbytes) = case.get("n").unwrap();
+            let (neg1, ubytes) = case.get("u").unwrap();
+            let (neg2, kbytes) = case.get("k").unwrap();
+
+            assert!(!neg0&&!neg1&&!neg2);
+            let n = $num::from_bytes(nbytes);
+            let n64 = $num64::from(&n);
+            let nu = $num64::from_bytes(ubytes);
+            let bigk = $num::from_bytes(kbytes);
+            let k = usize::from(bigk);
+            let e = $num::from(65537u64);
+            let pubkey2 = RSAPublicKey::<$num>::new(n.clone(), e.clone());
+            let pubkey1 = RSAPublicKey{ n: n, nu: $bar::from_components(k, n64, nu), e: e };
+            assert_eq!(pubkey1, pubkey2);
+        });
+    };
+}
+
+#[cfg(test)]
+macro_rules! encode_test_body {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
+        let fname = format!("testdata/rsa/sign{}.test", $size);
+        run_test(fname.to_string(), 7, |case| {
+            let (neg0, nbytes) = case.get("n").unwrap();
+            let (neg1, ubytes) = case.get("u").unwrap();
+            let (neg2, kbytes) = case.get("k").unwrap();
+
+            assert!(!neg0&&!neg1&&!neg2);
+            let n = $num::from_bytes(nbytes);
+            let n64 = $num64::from(&n);
+            let nu = $num64::from_bytes(ubytes);
+            let bigk = $num::from_bytes(kbytes);
+            let k = usize::from(bigk);
+            let e = $num::from(65537u64);
+            let pubkey = RSAPublicKey{ n: n, nu: $bar::from_components(k, n64, nu), e: e };
+            let asn1 = pubkey.to_asn1().unwrap();
+            let (pubkey2, _) = RSAPublicKey::from_asn1(&asn1).unwrap();
+            assert_eq!(pubkey, pubkey2);
+        });
+    };
+}
+
+#[cfg(test)]
+macro_rules! verify_test_body {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
+        let fname = format!("testdata/rsa/sign{}.test", $size);
+        run_test(fname.to_string(), 7, |case| {
+            let (neg0, nbytes) = case.get("n").unwrap();
+            let (neg1, hbytes) = case.get("h").unwrap();
+            let (neg2, mbytes) = case.get("m").unwrap();
+            let (neg3, sbytes) = case.get("s").unwrap();
+            let (neg4, ubytes) = case.get("u").unwrap();
+            let (neg5, kbytes) = case.get("k").unwrap();
+
+            assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5);
+            let n = $num::from_bytes(nbytes);
+            let n64 = $num64::from(&n);
+            let nu = $num64::from_bytes(ubytes);
+            let bigk = $num::from_bytes(kbytes);
+            let k = usize::from(bigk);
+            let e = $num::from(65537u64);
+            let pubkey = RSAPublicKey{ n: n, nu: $bar::from_components(k, n64, nu), e: e };
+            let hashnum = u64::from($num::from_bytes(hbytes));
+            let sighash = match hashnum {
+                            160 => &SIGNING_HASH_SHA1,
+                            224 => &SIGNING_HASH_SHA224,
+                            256 => &SIGNING_HASH_SHA256,
+                            384 => &SIGNING_HASH_SHA384,
+                            512 => &SIGNING_HASH_SHA512,
+                            _   => panic!("Bad signing hash: {}", hashnum)
+                          };
+            assert!(pubkey.verify(sighash, &mbytes, &sbytes));
+        });
+    };
+}
+
+#[cfg(test)]
+macro_rules! encrypt_test_body {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
+        let fname = format!("testdata/rsa/encrypt{}.test", $size);
+        run_test(fname.to_string(), 9, |case| {
+            let (neg0, nbytes) = case.get("n").unwrap();
+            let (neg1, hbytes) = case.get("h").unwrap();
+            let (neg2, mbytes) = case.get("m").unwrap();
+            let (neg3, _bytes) = case.get("e").unwrap();
+            let (neg4, ubytes) = case.get("u").unwrap();
+            let (neg5, kbytes) = case.get("k").unwrap();
+            let (neg6, dbytes) = case.get("d").unwrap();
+            let (neg7, lbytes) = case.get("l").unwrap();
+
+            assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5 && !neg6 && !neg7);
+            let n = $num::from_bytes(nbytes);
+            let n64 = $num64::from(&n);
+            let nu = $num64::from_bytes(ubytes);
+            let bigk = $num::from_bytes(kbytes);
+            let k = usize::from(bigk);
+            let e = $num::from(65537u64);
+            let d = $num::from_bytes(dbytes);
+            let nu = $bar::from_components(k, n64, nu);
+            let pubkey = RSAPublicKey{ n: n.clone(), nu: nu.clone(), e: e };
+            let privkey = RSAPrivateKey{ nu: nu, d: d };
+            let lstr = String::from_utf8(lbytes.clone()).unwrap();
+            let cipher = match usize::from($num::from_bytes(hbytes)) {
+                224 => pubkey.encrypt(&OAEPParams::<Sha224>::new(lstr.clone()), mbytes),
+                256 => pubkey.encrypt(&OAEPParams::<Sha256>::new(lstr.clone()), mbytes),
+                384 => pubkey.encrypt(&OAEPParams::<Sha384>::new(lstr.clone()), mbytes),
+                512 => pubkey.encrypt(&OAEPParams::<Sha512>::new(lstr.clone()), mbytes),
+                x   => panic!("Unknown hash number: {}", x)
+            };
+            assert!(cipher.is_ok());
+            let message = match usize::from($num::from_bytes(hbytes)) {
+                224 => privkey.decrypt(&OAEPParams::<Sha224>::new(lstr), &cipher.unwrap()),
+                256 => privkey.decrypt(&OAEPParams::<Sha256>::new(lstr), &cipher.unwrap()),
+                384 => privkey.decrypt(&OAEPParams::<Sha384>::new(lstr), &cipher.unwrap()),
+                512 => privkey.decrypt(&OAEPParams::<Sha512>::new(lstr), &cipher.unwrap()),
+                x   => panic!("Unknown hash number: {}", x)
+            };
+            assert!(message.is_ok());
+            assert_eq!(mbytes, &message.unwrap());
+        });
+    };
+}
 
 macro_rules! generate_tests {
-    ( $( ($mod: ident, $rsa: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) ),* ) => {
+    ($mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
-        $(
         #[cfg(test)]
         #[allow(non_snake_case)]
         mod $mod {
             use cryptonum::unsigned::Decoder;
             use super::*;
             use testing::run_test;
+            use rsa::private::*;
             use rsa::signing_hashes::*;
+            use sha2::{Sha224,Sha256,Sha384,Sha512};
 
             #[test]
-            fn encode() {
+            fn new() { new_test_body!($mod, $num, $bar, $num64, $size); }
-                let fname = format!("tests/rsa/rsa{}.test", $size);
-                run_test(fname.to_string(), 8, |case| {
-                    let (neg0, nbytes) = case.get("n").unwrap();
-                    let (neg1, ubytes) = case.get("u").unwrap();
-                    let (neg2, kbytes) = case.get("k").unwrap();
-
-                    assert!(!neg0&&!neg1&&!neg2);
-                    let n = $num::from_bytes(nbytes);
-                    println!("n:  {:X}", n);
-                    let n64 = $num64::from(&n);
-                    let nu = $num64::from_bytes(ubytes);
-                    let bigk = $num::from_bytes(kbytes);
-                    let k = usize::from(bigk);
-                    let e = $num::from(65537u64);
-                    let pubkey = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e };
-                    let asn1 = pubkey.to_asn1().unwrap();
-                    let (pubkey2, _) = $rsa::from_asn1(&asn1).unwrap();
-                    assert_eq!(pubkey, pubkey2);
-                });
-            }
-
             #[test]
-            fn verify() {
+            fn encode() { encode_test_body!($mod, $num, $bar, $num64, $size); }
-                let fname = format!("tests/rsa/rsa{}.test", $size);
-                run_test(fname.to_string(), 8, |case| {
-                    let (neg0, nbytes) = case.get("n").unwrap();
-                    let (neg1, hbytes) = case.get("h").unwrap();
-                    let (neg2, mbytes) = case.get("m").unwrap();
-                    let (neg3, sbytes) = case.get("s").unwrap();
-                    let (neg4, ubytes) = case.get("u").unwrap();
-                    let (neg5, kbytes) = case.get("k").unwrap();
-
-                    assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5);
-                    let n = $num::from_bytes(nbytes);
-                    let n64 = $num64::from(&n);
-                    let nu = $num64::from_bytes(ubytes);
-                    let bigk = $num::from_bytes(kbytes);
-                    let k = usize::from(bigk);
-                    let e = $num::from(65537u64);
-                    let pubkey = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e };
-                    let hashnum = ((hbytes[0] as u16)<<8) + (hbytes[1] as u16);
-                    let sighash = match hashnum {
-                                    0x160 => &SIGNING_HASH_SHA1,
-                                    0x224 => &SIGNING_HASH_SHA224,
-                                    0x256 => &SIGNING_HASH_SHA256,
-                                    0x384 => &SIGNING_HASH_SHA384,
-                                    0x512 => &SIGNING_HASH_SHA512,
-                                    _     => panic!("Bad signing hash: {}", hashnum)
-                                  };
-                    assert!(pubkey.verify(sighash, &mbytes, &sbytes));
-                });
-            }
-
             #[test]
-            fn encrypt() {
+            fn verify() { verify_test_body!($mod, $num, $bar, $num64, $size); }
-                let fname = format!("tests/rsa/rsa{}.test", $size);
+            #[test]
-                run_test(fname.to_string(), 8, |case| {
+            fn encrypt() { encrypt_test_body!($mod, $num, $bar, $num64, $size); }
-                    let (neg0, nbytes) = case.get("n").unwrap();
-                    let (neg1, hbytes) = case.get("h").unwrap();
-                    let (neg2, mbytes) = case.get("m").unwrap();
-                    let (neg3, sbytes) = case.get("s").unwrap();
-                    let (neg4, ubytes) = case.get("u").unwrap();
-                    let (neg5, kbytes) = case.get("k").unwrap();
-
-                    assert!(!neg0 && !neg1 && !neg2 && !neg3 && !neg4 && !neg5);
-                    let n = $num::from_bytes(nbytes);
-                    let n64 = $num64::from(&n);
-                    let nu = $num64::from_bytes(ubytes);
-                    let bigk = $num::from_bytes(kbytes);
-                    let k = usize::from(bigk);
-                    let e = $num::from(65537u64);
-                    let pubkey = $rsa{ n: n, nu: $bar::from_components(k, n64, nu), e: e };
-                    let hashnum = ((hbytes[0] as u16)<<8) + (hbytes[1] as u16);
-                    let sighash = match hashnum {
-                                    0x160 => &SIGNING_HASH_SHA1,
-                                    0x224 => &SIGNING_HASH_SHA224,
-                                    0x256 => &SIGNING_HASH_SHA256,
-                                    0x384 => &SIGNING_HASH_SHA384,
-                                    0x512 => &SIGNING_HASH_SHA512,
-                                    _     => panic!("Bad signing hash: {}", hashnum)
-                                  };
-                    assert!(pubkey.verify(sighash, &mbytes, &sbytes));
-                });
-             }
         }
-        )*
+    };
-    }
+    (ignore $mod: ident, $num: ident, $bar: ident, $num64: ident, $size: expr) => {
+        #[cfg(test)]
+        #[allow(non_snake_case)]
+        mod $mod {
+            use cryptonum::unsigned::Decoder;
+            use super::*;
+            use testing::run_test;
+            use rsa::private::*;
+            use rsa::signing_hashes::*;
+            use sha2::{Sha224,Sha256,Sha384,Sha512};
+
+            #[ignore]
+            #[test]
+            fn new() { new_test_body!($mod, $num, $bar, $num64, $size); }
+            #[ignore]
+            #[test]
+            fn encode() { encode_test_body!($mod, $num, $bar, $num64, $size); }
+            #[ignore]
+            #[test]
+            fn verify() { verify_test_body!($mod, $num, $bar, $num64, $size); }
+            #[ignore]
+            #[test]
+            fn encrypt() { encrypt_test_body!($mod, $num, $bar, $num64, $size); }
+        }
+    };
 }
 
-generate_tests!( (RSA512,   RSA512Public,   U512,   BarrettU512,   U576,   512),
+generate_tests!(       RSA512,   U512,   BarrettU512,   U576,   512);
-                 (RSA1024,  RSA1024Public,  U1024,  BarrettU1024,  U1088,  1024),
+generate_tests!(       RSA1024,  U1024,  BarrettU1024,  U1088,  1024);
-                 (RSA2048,  RSA2048Public,  U2048,  BarrettU2048,  U2112,  2048),
+generate_tests!(       RSA2048,  U2048,  BarrettU2048,  U2112,  2048);
-                 (RSA3072,  RSA3072Public,  U3072,  BarrettU3072,  U3136,  3072),
+generate_tests!(       RSA3072,  U3072,  BarrettU3072,  U3136,  3072);
-                 (RSA4096,  RSA4096Public,  U4096,  BarrettU4096,  U4160,  4096),
+generate_tests!(       RSA4096,  U4096,  BarrettU4096,  U4160,  4096);
-                 (RSA8192,  RSA8192Public,  U8192,  BarrettU8192,  U8256,  8192),
+generate_tests!(ignore RSA8192,  U8192,  BarrettU8192,  U8256,  8192);
-                 (RSA15360, RSA15360Public, U15360, BarrettU15360, U15424, 15360)
+generate_tests!(ignore RSA15360, U15360, BarrettU15360, U15424, 15360);
-               );

src/ssh/dsa.rs

@@ -0,0 +1,75 @@
+use cryptonum::unsigned::*;
+use dsa::{DSAKeyPair,DSAParameters,DSAPublicKey,DSAPrivateKey,L1024N160};
+use std::io::{Read,Write};
+use ssh::errors::{SSHKeyParseError,SSHKeyRenderError};
+use ssh::frame::*;
+use ssh::SSHKey;
+
+impl SSHKey for DSAKeyPair<L1024N160> {
+    fn valid_keytype(s: &str) -> bool {
+        (s == "ssh-dss") || (s == "dss")
+    }
+
+    fn parse_ssh_public_info<I: Read>(inp: &mut I) -> Result<Self::Public,SSHKeyParseError>
+    {
+        let pubkey_type = parse_openssh_string(inp)?;
+        if !Self::valid_keytype(&pubkey_type) {
+            return Err(SSHKeyParseError::UnknownKeyType(pubkey_type));
+        }
+        let pubp = parse_openssh_number(inp)?;
+        let pubq = parse_openssh_number(inp)?;
+        let pubg = parse_openssh_number(inp)?;
+        let pubparams = L1024N160::new(pubp, pubg, pubq);
+        let puby: U1024 = parse_openssh_number(inp)?;
+        for _ in inp.bytes() { return Err(SSHKeyParseError::UnknownTrailingData); }
+        Ok(DSAPublicKey::<L1024N160>::new(pubparams.clone(), puby.clone()))
+    }
+
+    fn parse_ssh_private_info<I: Read>(inp: &mut I) -> Result<(Self::Private,String),SSHKeyParseError>
+    {
+        let check1 = parse_openssh_u32(inp)?;
+        let check2 = parse_openssh_u32(inp)?;
+        if check1 != check2 {
+            return Err(SSHKeyParseError::PrivateKeyCorruption);
+        }
+        let privkey_type = parse_openssh_string(inp)?;
+        if !Self::valid_keytype(&privkey_type) {
+            return Err(SSHKeyParseError::InconsistentKeyTypes("ssh-dss".to_string(), privkey_type));
+        }
+        let privp = parse_openssh_number(inp)?;
+        let privq = parse_openssh_number(inp)?;
+        let privg = parse_openssh_number(inp)?;
+        let privparams = L1024N160::new(privp, privg, privq);
+        let _     = parse_openssh_buffer(inp)?; // a copy of y we don't need
+        let privx = parse_openssh_number(inp)?;
+
+        let privkey = DSAPrivateKey::<L1024N160>::new(privparams, privx);
+        let comment = parse_openssh_string(inp)?;
+        for (idx,byte) in inp.bytes().enumerate() {
+            if ((idx+1) as u8) != byte? {
+                return Err(SSHKeyParseError::InvalidPadding);
+            }
+        }
+
+        Ok((privkey,comment))
+    }
+
+    fn render_ssh_public_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        render_openssh_string(out, "ssh-dss")?;
+        render_openssh_number(out, &self.public.params.p)?;
+        render_openssh_number(out, &self.public.params.q)?;
+        render_openssh_number(out, &self.public.params.g)?;
+        render_openssh_number(out, &self.public.y)
+    }
+
+    fn render_ssh_private_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        render_openssh_string(out, "ssh-dss")?;
+        render_openssh_number(out, &self.private.params.p)?;
+        render_openssh_number(out, &self.private.params.q)?;
+        render_openssh_number(out, &self.private.params.g)?;
+        render_openssh_number(out, &self.public.y)?;
+        render_openssh_number(out, &self.private.x)
+   }
+}

src/ssh/ecdsa.rs

@@ -0,0 +1,171 @@
+use cryptonum::unsigned::*;
+use ecdsa::{ECDSAPair,ECDSAPublic,ECCPublicKey,ECDSAPrivate,ECCPrivateKey};
+use ecdsa::{EllipticCurve,P256,P384,P521};
+use std::io::{Read,Write};
+use ssh::errors::{SSHKeyParseError,SSHKeyRenderError};
+use ssh::frame::*;
+use ssh::SSHKey;
+
+impl SSHKey for ECDSAPair {
+    fn valid_keytype(s: &str) -> bool {
+        (s == "ssh-ecdsa") || (s == "ecdsa") || (s == "ecdsa-sha2-nistp256") ||
+        (s == "ecdsa-sha2-nistp384") || (s == "ecdsa-sha2-nistp521")
+    }
+
+    fn parse_ssh_public_info<I: Read>(inp: &mut I) -> Result<Self::Public,SSHKeyParseError>
+    {
+        let pubkey_type = parse_openssh_string(inp)?;
+        if !Self::valid_keytype(&pubkey_type) {
+            return Err(SSHKeyParseError::UnknownKeyType(pubkey_type));
+        }
+        // this peaks a little under the cover a bit (it'd be nice to pretend
+        // that we didn't know the number format was the same as the buffer
+        // one), but we need to infer what kind of key this is, and this appears
+        // to be the easiest / fastest way.
+        let curve = parse_openssh_string(inp)?;
+        match curve.as_ref() {
+            "nistp256" => {
+                let val = parse_openssh_buffer(inp)?;
+                if val[0] != 4 || val.len() != 65 {
+                    return Err(SSHKeyParseError::InvalidECPointCompression);
+                }
+                let x = U256::from_bytes(&val[1..33]);
+                let y = U256::from_bytes(&val[33..]);
+                let p = P256::new_point(x, y);
+                let pbl = ECCPublicKey::<P256>::new(p);
+                Ok(ECDSAPublic::P256(pbl))
+            }
+            "nistp384" => {
+                let val = parse_openssh_buffer(inp)?;
+                if val[0] != 4 || val.len() != 97 {
+                    return Err(SSHKeyParseError::InvalidECPointCompression);
+                }
+                let x = U384::from_bytes(&val[1..49]);
+                let y = U384::from_bytes(&val[49..]);
+                let p = P384::new_point(x, y);
+                let pbl = ECCPublicKey::<P384>::new(p);
+                Ok(ECDSAPublic::P384(pbl))
+            }
+            "nistp521" => {
+                let val = parse_openssh_buffer(inp)?;
+                if val[0] != 4 || val.len() != 133 {
+                    return Err(SSHKeyParseError::InvalidECPointCompression);
+                }
+                let x = U576::from_bytes(&val[1..67]);
+                let y = U576::from_bytes(&val[67..]);
+                let p = P521::new_point(x, y);
+                let pbl = ECCPublicKey::<P521>::new(p);
+                Ok(ECDSAPublic::P521(pbl))
+            }
+            _ => {
+                return Err(SSHKeyParseError::UnknownECDSACurve(curve))
+            }
+        }
+    }
+
+    fn parse_ssh_private_info<I: Read>(inp: &mut I) -> Result<(Self::Private,String),SSHKeyParseError>
+    {
+        let check1 = parse_openssh_u32(inp)?;
+        let check2 = parse_openssh_u32(inp)?;
+        if check1 != check2 {
+            return Err(SSHKeyParseError::PrivateKeyCorruption);
+        }
+        let res = match ECDSAPair::parse_ssh_public_info(inp)? {
+            ECDSAPublic::P192(_) => return Err(SSHKeyParseError::PrivateKeyCorruption),
+            ECDSAPublic::P224(_) => return Err(SSHKeyParseError::PrivateKeyCorruption),
+            ECDSAPublic::P256(_) => {
+                let mut dbytes = parse_openssh_buffer(inp)?;
+                while dbytes[0] == 0 { dbytes.remove(0); }
+                assert!(dbytes.len() <= 32);
+                let d = U256::from_bytes(&dbytes);
+                ECDSAPrivate::P256(ECCPrivateKey::<P256>::new(d))
+            }
+            ECDSAPublic::P384(_) => {
+                let mut dbytes = parse_openssh_buffer(inp)?;
+                while dbytes[0] == 0 { dbytes.remove(0); }
+                assert!(dbytes.len() <= 48);
+                let d = U384::from_bytes(&dbytes);
+                ECDSAPrivate::P384(ECCPrivateKey::<P384>::new(d))
+            }
+            ECDSAPublic::P521(_) => {
+                let mut dbytes = parse_openssh_buffer(inp)?;
+                while dbytes[0] == 0 { dbytes.remove(0); }
+                assert!(dbytes.len() <= 66);
+                let d = U576::from_bytes(&dbytes);
+                ECDSAPrivate::P521(ECCPrivateKey::<P521>::new(d))
+            }
+        };
+        let comment = parse_openssh_string(inp)?;
+        for (idx,byte) in inp.bytes().enumerate() {
+            if ((idx+1) as u8) != byte? {
+                return Err(SSHKeyParseError::InvalidPadding);
+            }
+        }
+
+        Ok((res, comment))
+    }
+
+    fn render_ssh_public_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        render_openssh_string(out, "ssh-ecdsa")?;
+        match self {
+            ECDSAPair::P192(_,_) =>
+                return Err(SSHKeyRenderError::IllegalECDSAKeyType("P192".to_string())),
+            ECDSAPair::P224(_,_) =>
+                return Err(SSHKeyRenderError::IllegalECDSAKeyType("P224".to_string())),
+            ECDSAPair::P256(pu,_) => {
+                render_openssh_string(out, "nistp256")?;
+                let mut vec = Vec::with_capacity(66);
+                vec.write(&[4u8])?;
+                render_number(256, &mut vec, &U256::from(pu.q.x.clone()))?;
+                render_number(256, &mut vec, &U256::from(pu.q.y.clone()))?;
+                render_openssh_buffer(out, &vec)?;
+            }
+            ECDSAPair::P384(pu,_) => {
+                render_openssh_string(out, "nistp384")?;
+                let mut vec = Vec::with_capacity(66);
+                vec.write(&[4u8])?;
+                render_number(384, &mut vec, &U384::from(pu.q.x.clone()))?;
+                render_number(384, &mut vec, &U384::from(pu.q.y.clone()))?;
+                render_openssh_buffer(out, &vec)?;
+            }
+            ECDSAPair::P521(pu,_) => {
+                render_openssh_string(out, "nistp521")?;
+                let mut vec = Vec::with_capacity(66);
+                vec.write(&[4u8])?;
+                render_number(521, &mut vec, &U576::from(pu.q.x.clone()))?;
+                render_number(521, &mut vec, &U576::from(pu.q.y.clone()))?;
+                render_openssh_buffer(out, &vec)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn render_ssh_private_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        self.render_ssh_public_info(out)?;
+        match self {
+            ECDSAPair::P192(_,_) =>
+                return Err(SSHKeyRenderError::IllegalECDSAKeyType("P192".to_string())),
+            ECDSAPair::P224(_,_) =>
+                return Err(SSHKeyRenderError::IllegalECDSAKeyType("P224".to_string())),
+            ECDSAPair::P256(_,pr) => { render_openssh_u32(out, 256/8)?; render_number(256, out, &pr.d)?; }
+            ECDSAPair::P384(_,pr) => { render_openssh_u32(out, 384/8)?; render_number(384, out, &pr.d)?; }
+            ECDSAPair::P521(_,pr) => { render_openssh_u32(out, 528/8)?; render_number(521, out, &pr.d)?; }
+        }
+        Ok(())
+    }
+}
+
+fn render_number<O,N>(bitlen: usize, out: &mut O, val: &N) -> Result<(),SSHKeyRenderError>
+ where
+  O: Write,
+  N: Encoder
+{
+    let mut outvec = Vec::new();
+    outvec.write(&val.to_bytes())?;
+    while outvec.len() < ((bitlen + 7) / 8) { outvec.insert(0,0); }
+    while outvec.len() > ((bitlen + 7) / 8) { outvec.remove(0);   }
+    out.write(&outvec)?;
+    Ok(())
+}

src/ssh/ed25519.rs

@@ -0,0 +1,58 @@
+use ed25519::{ED25519KeyPair,ED25519Private,ED25519Public};
+use std::io::{Read,Write};
+use ssh::errors::{SSHKeyParseError,SSHKeyRenderError};
+use ssh::frame::*;
+use ssh::SSHKey;
+
+impl SSHKey for ED25519KeyPair {
+    fn valid_keytype(s: &str) -> bool {
+        (s == "ssh-ed25519")
+    }
+
+    fn parse_ssh_public_info<I: Read>(inp: &mut I) -> Result<Self::Public,SSHKeyParseError>
+    {
+        let pubkey_type = parse_openssh_string(inp)?;
+        if !Self::valid_keytype(&pubkey_type) {
+            return Err(SSHKeyParseError::UnknownKeyType(pubkey_type));
+        }
+        let pubkey_bytes = parse_openssh_buffer(inp)?;
+        Ok(ED25519Public::new(&pubkey_bytes)?)
+    }
+
+    fn parse_ssh_private_info<I: Read>(inp: &mut I) -> Result<(Self::Private,String),SSHKeyParseError>
+    {
+        let check1 = parse_openssh_u32(inp)?;
+        let check2 = parse_openssh_u32(inp)?;
+        if check1 != check2 {
+            return Err(SSHKeyParseError::PrivateKeyCorruption);
+        }
+        let public = ED25519KeyPair::parse_ssh_public_info(inp)?;
+        let private_bytes = parse_openssh_buffer(inp)?; 
+        let private = ED25519Private::from_seed(&private_bytes[0..32]);
+        let comment = parse_openssh_string(inp)?;
+        for (idx,byte) in inp.bytes().enumerate() {
+            if ((idx+1) as u8) != byte? {
+                return Err(SSHKeyParseError::InvalidPadding);
+            }
+        }
+        assert_eq!(public, ED25519Public::from(&private));
+
+        Ok((private, comment))
+    }
+
+    fn render_ssh_public_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        render_openssh_string(out, "ssh-ed25519")?;
+        render_openssh_buffer(out, &self.public.to_bytes())?;
+        Ok(())
+    }
+
+    fn render_ssh_private_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        self.render_ssh_public_info(out)?;
+        let mut private_bytes = self.private.to_bytes();
+        private_bytes.append(&mut self.public.to_bytes());
+        render_openssh_buffer(out, &private_bytes)?;
+        Ok(())
+    }
+}

src/ssh/errors.rs

@@ -0,0 +1,68 @@
+use base64::DecodeError;
+use ed25519::ED25519PublicImportError;
+use std::io;
+
+/// A whole pile of errors that you can get when parsing an SSH key from
+/// disk or memory.
+#[derive(Debug)]
+pub enum SSHKeyParseError
+{
+    DecodeError(DecodeError),
+    IOError(io::Error),
+    NoBeginBannerFound, NoEndBannerFound,
+    NoOpenSSHMagicHeader,
+    UnknownKeyCipher(String),
+    UnknownKDF(String), UnexpectedKDFOptions,
+    InvalidNumberOfKeys(u32),
+    UnknownTrailingData,
+    UnknownKeyType(String),
+    InvalidPublicKeyMaterial,
+    PrivateKeyCorruption,
+    InconsistentKeyTypes(String,String),
+    InconsistentPublicKeyValue,
+    InvalidPrivateKeyValue,
+    InvalidPadding,
+    InvalidPublicKeyType,
+    BrokenPublicKeyLine,
+    UnknownECDSACurve(String),
+    InvalidECPointCompression
+}
+
+impl From<DecodeError> for SSHKeyParseError {
+    fn from(e: DecodeError) -> SSHKeyParseError {
+        SSHKeyParseError::DecodeError(e)
+    }
+}
+
+impl From<io::Error> for SSHKeyParseError {
+    fn from(e: io::Error) -> SSHKeyParseError {
+        SSHKeyParseError::IOError(e)
+    }
+}
+
+impl From<ED25519PublicImportError> for SSHKeyParseError {
+    fn from(e: ED25519PublicImportError) -> SSHKeyParseError {
+        match e {
+            ED25519PublicImportError::WrongNumberOfBytes(_) =>
+                SSHKeyParseError::InvalidPublicKeyMaterial,
+            ED25519PublicImportError::InvalidPublicPoint =>
+                SSHKeyParseError::InvalidPublicKeyMaterial,
+        }
+    }
+}
+
+/// A much smaller set of errors you can get when rendering an SSH key into
+/// a file or memory block.
+#[derive(Debug)]
+pub enum SSHKeyRenderError {
+    IOError(io::Error),
+    StringTooLong,
+    BufferTooLarge,
+    IllegalECDSAKeyType(String)
+}
+
+impl From<io::Error> for SSHKeyRenderError {
+    fn from(e: io::Error) -> SSHKeyRenderError {
+        SSHKeyRenderError::IOError(e)
+    }
+}

src/ssh/frame.rs

@@ -0,0 +1,308 @@
+use base64::{decode,encode};
+use byteorder::{BigEndian,ReadBytesExt,WriteBytesExt};
+use cryptonum::unsigned::{Decoder,Encoder};
+use ssh::errors::{SSHKeyParseError,SSHKeyRenderError};
+#[cfg(test)]
+use std::io::Cursor;
+#[cfg(test)]
+use std::fs::File;
+use std::io::Read;
+use std::io::Write;
+use std::iter::Iterator;
+
+const OPENER: &'static str = "-----BEGIN OPENSSH PRIVATE KEY-----\n";
+const CLOSER: &'static str = "-----END OPENSSH PRIVATE KEY-----";
+
+/// Given a string defining an ASCII SSH key blob (one that starts with
+/// "--BEGIN..."), decode the body of the blob and return it as binary
+/// data.
+pub fn parse_ssh_private_key_data(s: &str) -> Result<Vec<u8>,SSHKeyParseError>
+{
+    if s.starts_with(OPENER) {
+        if let Some(endidx) = s.find(CLOSER) {
+            let b64str: String = s[OPENER.len()..endidx].chars().filter(|x| *x != '\n').collect();
+            let bytes = decode(&b64str)?;
+            Ok(bytes)
+        } else {
+            Err(SSHKeyParseError::NoEndBannerFound)
+        }
+    } else {
+        Err(SSHKeyParseError::NoBeginBannerFound)
+    }
+}
+
+/// Once you've figured out the binary data you want to produce for an SSH key
+/// blob, use this routine to render it into its ASCII encoding.
+pub fn render_ssh_private_key_data(bytes: &[u8]) -> String
+{
+    let mut bytestr = encode(bytes);
+    let mut output = String::new();
+
+    output.push_str(OPENER);
+    while bytestr.len() > 70 {
+        let rest = bytestr.split_off(70);
+        output.push_str(&bytestr);
+        output.push_str("\n");
+        bytestr = rest;
+    }
+    output.push_str(&bytestr);
+    output.push_str("\n");
+    output.push_str(CLOSER);
+
+    output
+}
+
+//------------------------------------------------------------------------------
+
+const OPENSSH_MAGIC_HEADER: &'static str = "openssh-key-v1\0";
+const OPENSSH_MAGIC_HEADER_LEN: usize = 15;
+
+/// Parse the magic header in an SSH key file.
+pub fn parse_openssh_header<R: Read>(input: &mut R) -> Result<(),SSHKeyParseError>
+{
+    let mut limited_input_header = input.take(OPENSSH_MAGIC_HEADER_LEN as u64);
+    let mut header: [u8; OPENSSH_MAGIC_HEADER_LEN] = [0; OPENSSH_MAGIC_HEADER_LEN];
+
+    assert_eq!(OPENSSH_MAGIC_HEADER.len(), OPENSSH_MAGIC_HEADER_LEN);
+    limited_input_header.read_exact(&mut header)?;
+
+    for (left, right) in OPENSSH_MAGIC_HEADER.bytes().zip(header.iter()) {
+        if left != *right {
+            return Err(SSHKeyParseError::NoOpenSSHMagicHeader)
+        }
+
+    }
+
+    Ok(())
+}
+
+/// Render the magic header in an SSH key file.
+pub fn render_openssh_header<O: Write>(output: &mut O) -> Result<(),SSHKeyRenderError>
+{
+    Ok(output.write_all(OPENSSH_MAGIC_HEADER.as_bytes())?)
+}
+
+//------------------------------------------------------------------------------
+
+/// Parse an unsigned u32 from the SSH key stream. (This does the appropriate
+/// conversion from network order to native order.)
+pub fn parse_openssh_u32<I: Read>(input: &mut I) -> Result<u32,SSHKeyParseError>
+{
+    let mut limited_input_header = input.take(4);
+    let res = limited_input_header.read_u32::<BigEndian>()?;
+    Ok(res)
+}
+
+/// Render an unsigned u32 from the SSH key stream. (This does the appropriate
+/// conversion from network order to native order.)
+pub fn render_openssh_u32<O: Write>(output: &mut O, val: u32) -> Result<(),SSHKeyRenderError>
+{
+    Ok(output.write_u32::<BigEndian>(val)?)
+}
+
+//------------------------------------------------------------------------------
+
+/// Parse a string from the SSH key stream. This does some validation to ensure
+/// that the data being read is actually in a form that Rust will recognize as
+/// being a valid string.
+pub fn parse_openssh_string<I: Read>(input: &mut I) -> Result<String,SSHKeyParseError>
+{
+    let length = parse_openssh_u32(input)?;
+    let mut limited_input = input.take(length as u64);
+    let mut result = String::new();
+    limited_input.read_to_string(&mut result)?;
+    Ok(result)
+}
+
+/// Render a string into the SSH key stream.
+pub fn render_openssh_string<O: Write>(output: &mut O, v: &str) -> Result<(),SSHKeyRenderError>
+{
+    let vbytes: Vec<u8> = v.bytes().collect();
+    let len = vbytes.len();
+    
+    if len > 0xFFFFFFFF {
+        return Err(SSHKeyRenderError::StringTooLong);
+    }
+
+    render_openssh_u32(output, vbytes.len() as u32)?;
+    output.write_all(&vbytes)?;
+    Ok(())
+}
+
+//------------------------------------------------------------------------------
+
+/// Read a buffer from the SSH key stream.
+pub fn parse_openssh_buffer<I: Read>(input: &mut I) -> Result<Vec<u8>,SSHKeyParseError>
+{
+    let length = parse_openssh_u32(input)?;
+    let mut limited_input = input.take(length as u64);
+    let mut res = Vec::with_capacity(length as usize);
+    limited_input.read_to_end(&mut res)?;
+    Ok(res)
+}
+
+/// Render a buffer into the SSH key stream.
+pub fn render_openssh_buffer<O: Write>(output: &mut O, b: &[u8]) -> Result<(),SSHKeyRenderError>
+{
+    if b.len() > 0xFFFFFFFF {
+        return Err(SSHKeyRenderError::BufferTooLarge);
+    }
+
+    render_openssh_u32(output, b.len() as u32)?;
+    if b.len() > 0 {
+        output.write_all(b)?;
+    }
+
+    Ok(())
+}
+
+//------------------------------------------------------------------------------
+
+/// Parse a fixed-width number from the SSH key stream and return it.
+pub fn parse_openssh_number<I,D>(input: &mut I) -> Result<D,SSHKeyParseError>
+ where
+  I: Read,
+  D: Decoder
+{
+    let mut buffer = parse_openssh_buffer(input)?;
+    while buffer[0] == 0 { buffer.remove(0); }
+    Ok(D::from_bytes(&buffer))
+}
+
+/// Render a fixed-width number into the SSH key stream.
+pub fn render_openssh_number<O,D>(output: &mut O, n: &D) -> Result<(),SSHKeyRenderError>
+ where
+  O: Write,
+  D: Encoder
+{
+    let bytes = n.to_bytes();
+    render_openssh_buffer(output, &bytes)
+}
+
+//------------------------------------------------------------------------------
+
+#[cfg(test)]
+use cryptonum::unsigned::{U192,U1024,U2048,U4096};
+
+#[cfg(test)]
+quickcheck! {
+    fn bytes_roundtrip(x: Vec<u8>) -> bool {
+        let rendered = render_ssh_private_key_data(&x);
+        let returned = parse_ssh_private_key_data(&rendered).unwrap();
+        returned == x
+    }
+
+    fn blocks_formatted(x: Vec<u8>) -> bool {
+        let rendered = render_ssh_private_key_data(&x);
+        let mut is_ok = true;
+
+        for line in rendered.lines() {
+            is_ok &= line.len() <= 70;
+        }
+
+        is_ok
+    }
+
+    fn u32s_roundtrip_rp(x: u32) -> bool {
+        let mut buffer = vec![];
+        render_openssh_u32(&mut buffer, x).unwrap();
+        let mut cursor = Cursor::new(buffer);
+        let check = parse_openssh_u32(&mut cursor).unwrap();
+        x == check
+    }
+
+    fn u32s_roundtrip_pr(a: u8, b: u8, c: u8, d: u8) -> bool {
+        let block = [a,b,c,d];
+        let mut cursor = Cursor::new(block);
+        let base = parse_openssh_u32(&mut cursor).unwrap();
+        let mut rendered = vec![];
+        render_openssh_u32(&mut rendered, base).unwrap();
+        (block[0] == rendered[0]) &&
+        (block[1] == rendered[1]) &&
+        (block[2] == rendered[2]) &&
+        (block[3] == rendered[3])
+    }
+
+    fn string_roundtrip(s: String) -> bool {
+        let mut buffer = vec![];
+        render_openssh_string(&mut buffer, &s).unwrap();
+        let mut cursor = Cursor::new(buffer);
+        let check = parse_openssh_string(&mut cursor).unwrap();
+        s == check
+    }
+
+    fn buffer(os: Vec<u8>) -> bool {
+        let mut buffer = vec![];
+        render_openssh_buffer(&mut buffer, &os).unwrap();
+        let mut cursor = Cursor::new(buffer);
+        let check = parse_openssh_buffer(&mut cursor).unwrap();
+        os == check
+    }
+
+    fn u192(x: U192) -> bool {
+        let mut buffer = vec![];
+        render_openssh_number(&mut buffer, &x).unwrap();
+        let mut cursor = Cursor::new(buffer);
+        let check: U192 = parse_openssh_number(&mut cursor).unwrap();
+        check == x
+    }
+
+    fn u1024(x: U1024) -> bool {
+        let mut buffer = vec![];
+        render_openssh_number(&mut buffer, &x).unwrap();
+        let mut cursor = Cursor::new(buffer);
+        let check: U1024 = parse_openssh_number(&mut cursor).unwrap();
+        check == x
+    }
+
+    fn u2048(x: U2048) -> bool {
+        let mut buffer = vec![];
+        render_openssh_number(&mut buffer, &x).unwrap();
+        let mut cursor = Cursor::new(buffer);
+        let check: U2048 = parse_openssh_number(&mut cursor).unwrap();
+        check == x
+    }
+
+    fn u4096(x: U4096) -> bool {
+        let mut buffer = vec![];
+        render_openssh_number(&mut buffer, &x).unwrap();
+        let mut cursor = Cursor::new(buffer);
+        let check: U4096 = parse_openssh_number(&mut cursor).unwrap();
+        check == x
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn pregenerated_reencode() {
+    let test_files = ["dsa1024-1", "dsa1024-2", "dsa1024-3",
+                      "ecdsa256-1", "ecdsa256-2", "ecdsa256-3",
+                      "ecdsa384-1", "ecdsa384-2", "ecdsa384-3",
+                      "ecdsa521-1", "ecdsa521-2", "ecdsa521-3",
+                      "ed25519-1", "ed25519-2", "ed25519-3",
+                      "rsa1024-1", "rsa1024-2", "rsa1024-3",
+                      "rsa2048-1", "rsa2048-2", "rsa2048-3",
+                      "rsa3072-1", "rsa3072-2", "rsa3072-3",
+                      "rsa4096-1", "rsa4096-2", "rsa4096-3",
+                      "rsa8192-1", "rsa8192-2", "rsa8192-3" ];
+
+    for file in test_files.iter() {
+        let path = format!("testdata/ssh/{}",file);
+        let mut fd = File::open(path).unwrap();
+        let mut contents = String::new();
+        fd.read_to_string(&mut contents).unwrap();
+        let parsed = parse_ssh_private_key_data(&contents).unwrap();
+        let rendered = render_ssh_private_key_data(&parsed);
+        // starts_with() avoids newline unpleasantness
+        assert!(contents.starts_with(&rendered));
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn header_roundtrips() {
+    let mut vec = Vec::new();
+    assert!(render_openssh_header(&mut vec).is_ok());
+    let mut cursor = Cursor::new(vec);
+    assert!(parse_openssh_header(&mut cursor).is_ok());
+}

src/ssh/mod.rs

@@ -0,0 +1,428 @@
+//! Most of the routines you want are exported from this module as functions,
+//! not as structs, macros, enums, or what have you. In particular, you
+//! probably want the `decode` or `encode` functions, or one of the functions
+//! that `load`s data from disk or `write`s it. Here's some example code
+//! to get you started, using a generated ED25519 key for fun:
+//!
+//! ```rust
+//! use simple_crypto::ed25519::ED25519KeyPair;
+//! use simple_crypto::ssh::*;
+//! 
+//! // Generate a new ED25519 key
+//! let mut rng = rand::rngs::OsRng::new().unwrap();
+//! let kp = ED25519KeyPair::generate(&mut rng);
+//! 
+//! // Now that we have it, we can encode it as a handy ASCII string in memory,
+//! // using a totally fake email address for fun:
+//! let ascii_rep = encode_ssh(&kp, "fake@email.addr").expect("Encode failure!");
+//! 
+//! // As usual, we should be able to decode anything we encode, and the
+//! // keys should match:
+//! let (kp2, addr2) = decode_ssh(&ascii_rep).expect("Decode failure!");
+//! assert_eq!(kp, kp2);
+//! assert_eq!(&addr2, "fake@email.addr");
+//!
+//! // If you want to write this to a file, you can just do so directly:
+//! write_ssh_keyfile("test.ed25519", &kp, "fake@email.addr").expect("write error");
+//! // And then load it back:
+//! let (kp3, addr3) = load_ssh_keyfile("test.ed25519").expect("load error");
+//! // And, of course, it should be the same.
+//! assert_eq!(kp, kp3);
+//! assert_eq!(addr2, addr3);
+//! ```
+mod dsa;
+mod ecdsa;
+mod ed25519;
+mod errors;
+pub mod frame;
+mod rsa;
+
+pub use self::errors::{SSHKeyParseError,SSHKeyRenderError};
+
+use base64::decode;
+use self::frame::*;
+use std::fs::File;
+use std::io::{Cursor,Read,Write};
+use std::path::Path;
+use super::KeyPair;
+
+/// A trait defining keys that can be parsed / rendered by this library. Note
+/// that you probably don't want to use these routines directly; they're mostly
+/// used by the internal functions. Perhaps the only reason to use them is to
+/// implement them, because you've got another kind of key you want to parse that
+/// isn't already part of the library. (In that case, though ... maybe send a
+/// patch?)
+pub trait SSHKey: Sized + KeyPair {
+    /// Return true if the given string is a valid key type identifier for this
+    /// key type. (i.e., "ssh-ed25519" is the identifier for ED25519, and "dss"
+    /// and "ssh-dss" are both valid identifiers for DSA keys.)
+    fn valid_keytype(s: &str) -> bool;
+
+    /// Parse the public blob info within an SSH blob. I strongly recommend
+    /// using the functions in `ssh::frame` for this.
+    fn parse_ssh_public_info<I: Read>(inp: &mut I) -> Result<Self::Public,SSHKeyParseError>;
+    /// Parse the private blob info within an SSH blob. I strongly recommend
+    /// using the functions in `ssh::frame` for this.
+    fn parse_ssh_private_info<I: Read>(inp: &mut I) -> Result<(Self::Private,String),SSHKeyParseError>;
+
+    /// Render the public blob info within an SSH blob. I strongly recommend
+    /// using the functions in `ssh::frame` for this.
+    fn render_ssh_public_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>;
+    /// Render the private blob info within an SSH blob. I strongly recommend
+    /// using the functions in `ssh::frame` for this.
+    fn render_ssh_private_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>;
+}
+
+/// Decode a string containing a private key into the appropriate key type and
+/// the comment associated with it, usually an email address or similar.
+pub fn decode_ssh<KP: SSHKey>(x: &str) -> Result<(KP, String),SSHKeyParseError>
+{
+    let bytes = parse_ssh_private_key_data(x)?;
+    let data_size = bytes.len() as u64;
+    let mut byte_cursor = Cursor::new(bytes);
+
+    parse_openssh_header(&mut byte_cursor)?;
+    let ciphername = parse_openssh_string(&mut byte_cursor)?;
+    if ciphername != "none" {
+        return Err(SSHKeyParseError::UnknownKeyCipher(ciphername));
+    }
+    let kdfname = parse_openssh_string(&mut byte_cursor)?;
+    if kdfname != "none" {
+        return Err(SSHKeyParseError::UnknownKeyCipher(kdfname));
+    }
+    let kdfoptions = parse_openssh_buffer(&mut byte_cursor)?;
+    if kdfoptions.len() > 0 {
+        return Err(SSHKeyParseError::UnexpectedKDFOptions);
+    }
+    let numkeys = parse_openssh_u32(&mut byte_cursor)?;
+    if numkeys != 1 {
+        return Err(SSHKeyParseError::InvalidNumberOfKeys(numkeys));
+    }
+    let pubkey0 = parse_openssh_buffer(&mut byte_cursor)?;
+    let privkeys = parse_openssh_buffer(&mut byte_cursor)?;
+    if byte_cursor.position() < data_size {
+        return Err(SSHKeyParseError::UnknownTrailingData);
+    }
+
+    let mut pubcursor = Cursor::new(pubkey0);
+    let public = KP::parse_ssh_public_info(&mut pubcursor)?;
+    let mut privcursor = Cursor::new(privkeys);
+    let (private, comment) = KP::parse_ssh_private_info(&mut privcursor)?;
+
+    Ok((KP::new(public, private), comment))
+}
+
+/// Decode a string containing a public key into an appropriate key type and
+/// the comment associated with it, usually an email address or similar.
+pub fn decode_ssh_pubkey<KP: SSHKey>(s: &str) -> Result<(KP::Public, String),SSHKeyParseError>
+{
+    let mut splitter = s.split_whitespace();
+
+    match (splitter.next(), splitter.next(), splitter.next(), splitter.next()) {
+        (Some(keytype), Some(keymaterial), Some(comment), None) => {
+            if !KP::valid_keytype(keytype) {
+                return Err(SSHKeyParseError::InvalidPublicKeyType);
+            }
+
+            let bytes = decode(keymaterial)?;
+            let mut byte_cursor = Cursor::new(bytes);
+            let key = KP::parse_ssh_public_info(&mut byte_cursor)?;
+
+            Ok((key, comment.to_string()))
+        }
+        _ =>
+            Err(SSHKeyParseError::BrokenPublicKeyLine)
+    }
+}
+
+/// Load an SSH private key file, returning the appropriate key type and the
+/// comment associated with it.
+pub fn load_ssh_keyfile<KP,P>(path: P) -> Result<(KP, String),SSHKeyParseError>
+ where
+  KP: SSHKey,
+  P: AsRef<Path>
+{
+    let mut file = File::open(path)?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    decode_ssh(&contents)
+}
+
+/// Load all the public keys from a file into memory.
+pub fn load_ssh_pubkeys<KP,P>(path: P) -> Result<Vec<(KP::Public, String)>,SSHKeyParseError>
+ where
+  KP: SSHKey,
+  P: AsRef<Path>
+{
+    let mut file = File::open(path)?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    let mut result = Vec::new();
+
+    for line in contents.lines() {
+        result.push( decode_ssh_pubkey::<KP>(line)? );
+    }
+
+    Ok(result)
+}
+
+/// Encode a supported key into its ASCII SSH format, with the given comment.
+pub fn encode_ssh<KP: SSHKey>(x: &KP, comment: &str) -> Result<String,SSHKeyRenderError>
+{
+    let mut pubkeybin = Vec::with_capacity(8192);
+    let mut privkeybin = Vec::with_capacity(8192);
+    let mut binary = Vec::with_capacity(16384);
+
+    // create the public key bits
+    x.render_ssh_public_info(&mut pubkeybin)?;
+    // create the private key bits
+    render_openssh_u32(&mut privkeybin, 0xDEADBEEF)?; // FIXME: Any reason for this to be random?
+    render_openssh_u32(&mut privkeybin, 0xDEADBEEF)?; // ditto
+    x.render_ssh_private_info(&mut privkeybin)?;
+    render_openssh_string(&mut privkeybin, comment)?;
+    // add some padding (not quite sure why)
+    let mut i = comment.len();
+    while (i % 16) != 0 {
+        privkeybin.write(&[(i - comment.len() + 1) as u8])?;
+        i += 1;
+    }
+    // render a bunch of the framing stuff
+    render_openssh_header(&mut binary)?;
+    render_openssh_string(&mut binary, "none")?; // ciphername
+    render_openssh_string(&mut binary, "none")?; // kdfname
+    render_openssh_buffer(&mut binary, &[])?; // kdfoptions
+    render_openssh_u32(&mut binary, 1)?; // numkeys
+    render_openssh_buffer(&mut binary, &pubkeybin)?;
+    render_openssh_buffer(&mut binary, &privkeybin)?;
+    Ok(render_ssh_private_key_data(&binary))
+}
+
+/// Encode a supported key into the given file, with the given comment.
+pub fn write_ssh_keyfile<KP,P>(path: P, x: &KP, comment: &str) -> Result<(),SSHKeyRenderError>
+ where
+  KP: SSHKey,
+  P: AsRef<Path>
+{
+    let mut file = File::create(path)?;
+    let contents = encode_ssh(x, comment)?;
+    let bytes = contents.into_bytes();
+    file.write_all(&bytes)?;
+    file.sync_all()?;
+    Ok(())
+}
+
+#[cfg(test)]
+use dsa::{DSAKeyPair,DSAPublicKey,L1024N160};
+#[cfg(test)]
+use ecdsa::ECDSAPair;
+#[cfg(test)]
+use ed25519::ED25519KeyPair;
+#[cfg(test)]
+use rsa::{RSAPair,RSAPublic,SIGNING_HASH_SHA256};
+#[cfg(test)]
+use sha2::Sha256;
+
+#[cfg(test)]
+#[test]
+fn dsa_examples() {
+    let test_files = ["dsa1024-1", "dsa1024-2", "dsa1024-3"];
+
+    for file in test_files.iter() {
+        let path = format!("testdata/ssh/{}",file);
+        let mkeypair = load_ssh_keyfile(path);
+        match mkeypair {
+            Err(e) => assert!(false, format!("reading error: {:?}", e)),
+            Ok((keypair, comment)) => {
+                let buffer = [0,1,2,3,4,6,2];
+                let _ : DSAKeyPair<L1024N160> = keypair;
+                let sig = keypair.private.sign::<Sha256>(&buffer);
+                assert!(keypair.public.verify::<Sha256>(&buffer, &sig));
+                let buffer2 = [0,1,2,3,4,6,5];
+                assert!(!keypair.public.verify::<Sha256>(&buffer2, &sig));
+                match encode_ssh(&keypair, &comment) {
+                    Err(e2) => assert!(false, format!("render error: {:?}", e2)),
+                    Ok(encodedstr) => {
+                        match decode_ssh(&encodedstr) {
+                            Err(e3) => assert!(false, format!("reparse error: {:?}", e3)),
+                            Ok((keypair2,comment2)) => {
+                                let _ : DSAKeyPair<L1024N160> = keypair2;
+                                assert_eq!(keypair.public.params.p,keypair2.public.params.p,"failed to reparse key pair (p)");
+                                assert_eq!(keypair.public.params.q,keypair2.public.params.q,"failed to reparse key pair (q)");
+                                assert_eq!(keypair.public.params.g,keypair2.public.params.g,"failed to reparse key pair (g)");
+                                assert_eq!(keypair.private.params.p,keypair2.private.params.p,"failed to reparse key pair (p)");
+                                assert_eq!(keypair.private.params.q,keypair2.private.params.q,"failed to reparse key pair (q)");
+                                assert_eq!(keypair.private.params.g,keypair2.private.params.g,"failed to reparse key pair (g)");
+                                assert_eq!(keypair.public.y,keypair2.public.y,"failed to reparse key pair (y)");
+                                assert_eq!(keypair.private.x,keypair2.private.x,"failed to reparse key pair (x)");
+                                assert_eq!(comment,comment2,"failed to reparse comment");
+                                let ppath = format!("testdata/ssh/{}.pub",file);
+                                match load_ssh_pubkeys::<DSAKeyPair<L1024N160>,String>(ppath) {
+                                    Err(e4) => assert!(false, format!("pubkey error: {:?}", e4)),
+                                    Ok(pubkeys) => {
+                                        let _ : Vec<(DSAPublicKey<L1024N160>,String)> = pubkeys;
+                                        for (pubkey, comment3) in pubkeys {
+                                            assert_eq!(pubkey.params.p, keypair.public.params.p, "public key check (p)");
+                                            assert_eq!(pubkey.params.q, keypair.public.params.q, "public key check (q)");
+                                            assert_eq!(pubkey.params.g, keypair.public.params.g, "public key check (g)");
+                                            assert_eq!(pubkey.y,        keypair.public.y,        "public key check (y)");
+                                            assert_eq!(comment,         comment3,                "public key check comment")
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn rsa_examples() {
+    let test_files = ["rsa1024-1", "rsa1024-2", "rsa1024-3",
+                      "rsa2048-1", "rsa2048-2", "rsa2048-3",
+                      "rsa3072-1", "rsa3072-2", "rsa3072-3",
+                      "rsa4096-1", "rsa4096-2", "rsa4096-3",
+                      "rsa8192-1", "rsa8192-2", "rsa8192-3"];
+
+    for file in test_files.iter() {
+        let path = format!("testdata/ssh/{}",file);
+        let mkeypair = load_ssh_keyfile::<RSAPair,String>(path);
+        match mkeypair {
+            Err(e) => assert!(false, format!("reading error: {:?}", e)),
+            Ok((keypair, comment)) => {
+                let buffer = [0,1,2,3,4,6,2];
+                let sig = keypair.sign(&SIGNING_HASH_SHA256, &buffer);
+                assert!(keypair.verify(&SIGNING_HASH_SHA256, &buffer, &sig));
+                match encode_ssh(&keypair, &comment) {
+                    Err(e2) => assert!(false, format!("render error: {:?}", e2)),
+                    Ok(encodedstr) => {
+                        match decode_ssh(&encodedstr) {
+                            Err(e3) => assert!(false, format!("reparse error: {:?}", e3)),
+                            Ok((keypair2,comment2)) => {
+                                assert_eq!(keypair,keypair2,"failed to reparse key pair");
+                                assert_eq!(comment,comment2,"failed to reparse comment");
+                                let ppath = format!("testdata/ssh/{}.pub",file);
+                                match load_ssh_pubkeys::<RSAPair,String>(ppath) {
+                                    Err(e4) => assert!(false, format!("pubkey error: {:?}", e4)),
+                                    Ok(pubkeys) => {
+                                        let _ : Vec<(RSAPublic,String)> = pubkeys;
+                                        for (pubkey, comment3) in pubkeys {
+                                            assert_eq!(pubkey,  keypair.public(), "public key check");
+                                            assert_eq!(comment, comment3,         "public key check comment");
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn ecdsa_examples() {
+    let test_files = ["ecdsa256-1", "ecdsa256-2", "ecdsa256-3",
+                      "ecdsa384-1", "ecdsa384-2", "ecdsa384-3",
+                      "ecdsa521-1", "ecdsa521-2", "ecdsa521-3"];
+
+    for file in test_files.iter() {
+        let path = format!("testdata/ssh/{}",file);
+        match load_ssh_keyfile::<ECDSAPair,String>(path) {
+            Err(e) =>
+                assert!(false, "SSH ECDSA parse error: {:?}", e),
+            Ok((keypair,comment)) => {
+                // first see if this roundtrips
+                let buffer = vec![0,1,2,4,5,6,9];
+                match keypair {
+                    ECDSAPair::P192(_,_) =>
+                        assert!(false, "Somehow got a P192 in read test"),
+                    ECDSAPair::P224(_,_) =>
+                        assert!(false, "Somehow got a P224 in read test"),
+                    ECDSAPair::P256(ref pu, ref pr) => {
+                        let sig = pr.sign::<Sha256>(&buffer);
+                        assert!(pu.verify::<Sha256>(&buffer, &sig));
+                    }
+                    ECDSAPair::P384(ref pu, ref pr) => {
+                        let sig = pr.sign::<Sha256>(&buffer);
+                        assert!(pu.verify::<Sha256>(&buffer, &sig));
+                    }
+                    ECDSAPair::P521(ref pu, ref pr) => {
+                        let sig = pr.sign::<Sha256>(&buffer);
+                        assert!(pu.verify::<Sha256>(&buffer, &sig));
+                    }
+                }
+                // encode this, parse it again
+                match encode_ssh(&keypair, &comment) {
+                    Err(e) =>
+                        assert!(false, "SSH ECDSA encoding error: {:?}", e),
+                    Ok(coded) => {
+                       match (decode_ssh(&coded), keypair) {
+                           (Err(e), _) =>
+                             assert!(false, "SSSH ECDSA redecoding error: {:?}", e),
+                           (Ok((ECDSAPair::P256(pu2, pr2), comment2)), ECDSAPair::P256(pu,pr)) => {
+                               assert_eq!(pu, pu2, "public key mismatch");
+                               assert_eq!(pr, pr2, "public key mismatch");
+                               assert_eq!(comment, comment2, "comment mismatch");
+                           }
+                           (Ok((ECDSAPair::P384(pu2, pr2), comment2)), ECDSAPair::P384(pu,pr)) => {
+                               assert_eq!(pu, pu2, "public key mismatch");
+                               assert_eq!(pr, pr2, "public key mismatch");
+                               assert_eq!(comment, comment2, "comment mismatch");
+                           }
+                           (Ok((ECDSAPair::P521(pu2, pr2), comment2)), ECDSAPair::P521(pu,pr)) => {
+                               assert_eq!(pu, pu2, "public key mismatch");
+                               assert_eq!(pr, pr2, "public key mismatch");
+                               assert_eq!(comment, comment2, "comment mismatch");
+                           }
+                           _ =>
+                             assert!(false, "Failed to accurately re-parse key")
+                       } 
+                    }
+                }
+            }
+        }
+    }
+}
+ 
+#[cfg(test)]
+#[test]
+fn ed25519_examples() {
+    let test_files = ["ed25519-1", "ed25519-2", "ed25519-3"];
+
+    for file in test_files.iter() {
+        let path = format!("testdata/ssh/{}",file);
+        match load_ssh_keyfile::<ED25519KeyPair,String>(path) {
+            Err(e) =>
+                assert!(false, "SSH ED25519 parse error: {:?}", e),
+            Ok((keypair,comment)) => {
+                // first see if this roundtrips
+                let buffer = vec![0,1,2,4,5,6,9];
+                let sig = keypair.private.sign(&buffer);
+                assert!(keypair.public.verify(&buffer, &sig));
+                match encode_ssh(&keypair, &comment) {
+                    Err(e) =>
+                        assert!(false, "SSH ED25519 encoding error: {:?}", e),
+                    Ok(coded) => {
+                       match decode_ssh(&coded) {
+                           Err(e) =>
+                             assert!(false, "SSSH ECDSA redecoding error: {:?}", e),
+                           Ok((keypair2, comment2)) => {
+                               let _ : ED25519KeyPair = keypair2;
+                               assert_eq!(keypair.public, keypair2.public, "public key mismatch");
+                               assert_eq!(keypair.private, keypair2.private, "public key mismatch");
+                               assert_eq!(comment, comment2, "comment mismatch");
+                           }
+                       } 
+                    }
+                }
+            }
+        }
+    }
+}
+ 

src/ssh/rsa.rs

@@ -0,0 +1,201 @@
+use cryptonum::unsigned::*;
+use rsa::{RSAPair,RSAPublic,RSAPublicKey,RSAPrivate,RSAPrivateKey};
+use std::io::{Read,Write};
+use ssh::errors::{SSHKeyParseError,SSHKeyRenderError};
+use ssh::frame::*;
+use ssh::SSHKey;
+
+impl SSHKey for RSAPair {
+    fn valid_keytype(s: &str) -> bool {
+        (s == "ssh-rsa") || (s == "rsa")
+    }
+
+    fn parse_ssh_public_info<I: Read>(inp: &mut I) -> Result<Self::Public,SSHKeyParseError>
+    {
+        let pubkey_type = parse_openssh_string(inp)?;
+        if !Self::valid_keytype(&pubkey_type) {
+            return Err(SSHKeyParseError::UnknownKeyType(pubkey_type));
+        }
+        // this peaks a little under the cover a bit (it'd be nice to pretend
+        // that we didn't know the number format was the same as the buffer
+        // one), but we need to infer what kind of key this is, and this appears
+        // to be the easiest / fastest way.
+        let mut ebuf = parse_openssh_buffer(inp)?;
+        let mut nbuf = parse_openssh_buffer(inp)?;
+
+        while ebuf[0] == 0 { ebuf.remove(0); }
+        while nbuf[0] == 0 { nbuf.remove(0); }
+
+        if nbuf.len() > (8192 / 8) {
+            let e = U15360::from_bytes(&ebuf);
+            let n = U15360::from_bytes(&nbuf);
+            Ok(RSAPublic::Key15360(RSAPublicKey::<U15360>::new(n, e)))
+        } else if nbuf.len() > (4096 / 8) {
+            let e = U8192::from_bytes(&ebuf);
+            let n = U8192::from_bytes(&nbuf);
+            Ok(RSAPublic::Key8192(RSAPublicKey::<U8192>::new(n, e)))
+        } else if nbuf.len() > (3072 / 8) {
+            let e = U4096::from_bytes(&ebuf);
+            let n = U4096::from_bytes(&nbuf);
+            Ok(RSAPublic::Key4096(RSAPublicKey::<U4096>::new(n, e)))
+        } else if nbuf.len() > (2048 / 8) {
+            let e = U3072::from_bytes(&ebuf);
+            let n = U3072::from_bytes(&nbuf);
+            Ok(RSAPublic::Key3072(RSAPublicKey::<U3072>::new(n, e)))
+        } else if nbuf.len() > (1024 / 8) {
+            let e = U2048::from_bytes(&ebuf);
+            let n = U2048::from_bytes(&nbuf);
+            Ok(RSAPublic::Key2048(RSAPublicKey::<U2048>::new(n, e)))
+        } else if nbuf.len() > (512 / 8) {
+            let e = U1024::from_bytes(&ebuf);
+            let n = U1024::from_bytes(&nbuf);
+            Ok(RSAPublic::Key1024(RSAPublicKey::<U1024>::new(n, e)))
+        } else {
+            let e = U512::from_bytes(&ebuf);
+            let n = U512::from_bytes(&nbuf);
+            Ok(RSAPublic::Key512(RSAPublicKey::<U512>::new(n, e)))
+        }
+    }
+
+    fn parse_ssh_private_info<I: Read>(inp: &mut I) -> Result<(Self::Private,String),SSHKeyParseError>
+    {
+        let check1 = parse_openssh_u32(inp)?;
+        let check2 = parse_openssh_u32(inp)?;
+        if check1 != check2 {
+            return Err(SSHKeyParseError::PrivateKeyCorruption);
+        }
+        let privkey_type = parse_openssh_string(inp)?;
+        if !Self::valid_keytype(&privkey_type) {
+            return Err(SSHKeyParseError::InconsistentKeyTypes("ssh-rsa".to_string(), privkey_type));
+        }
+
+        // See the comment in the public key section.
+        let mut nbuf = parse_openssh_buffer(inp)?;
+        let    _ebuf = parse_openssh_buffer(inp)?;
+        let mut dbuf = parse_openssh_buffer(inp)?;
+        let    _iqmp = parse_openssh_buffer(inp)?;
+        let    _pbuf = parse_openssh_buffer(inp)?;
+        let    _qbuf = parse_openssh_buffer(inp)?;
+        let  comment = parse_openssh_string(inp)?;
+        for (idx,byte) in inp.bytes().enumerate() {
+            if ((idx+1) as u8) != byte? {
+                return Err(SSHKeyParseError::InvalidPadding);
+            }
+        }
+
+        while dbuf[0] == 0 { dbuf.remove(0); }
+        while nbuf[0] == 0 { nbuf.remove(0); }
+
+        if nbuf.len() > (8192 / 8) {
+            let d = U15360::from_bytes(&dbuf);
+            let n = U15360::from_bytes(&nbuf);
+            Ok((RSAPrivate::Key15360(RSAPrivateKey::<U15360>::new(n, d)), comment))
+        } else if nbuf.len() > (4096 / 8) {
+            let d = U8192::from_bytes(&dbuf);
+            let n = U8192::from_bytes(&nbuf);
+            Ok((RSAPrivate::Key8192(RSAPrivateKey::<U8192>::new(n, d)), comment))
+        } else if nbuf.len() > (3072 / 8) {
+            let d = U4096::from_bytes(&dbuf);
+            let n = U4096::from_bytes(&nbuf);
+            Ok((RSAPrivate::Key4096(RSAPrivateKey::<U4096>::new(n, d)), comment))
+        } else if nbuf.len() > (2048 / 8) {
+            let d = U3072::from_bytes(&dbuf);
+            let n = U3072::from_bytes(&nbuf);
+            Ok((RSAPrivate::Key3072(RSAPrivateKey::<U3072>::new(n, d)), comment))
+        } else if nbuf.len() > (1024 / 8) {
+            let d = U2048::from_bytes(&dbuf);
+            let n = U2048::from_bytes(&nbuf);
+            Ok((RSAPrivate::Key2048(RSAPrivateKey::<U2048>::new(n, d)), comment))
+        } else if nbuf.len() > (512 / 8) {
+            let d = U1024::from_bytes(&dbuf);
+            let n = U1024::from_bytes(&nbuf);
+            Ok((RSAPrivate::Key1024(RSAPrivateKey::<U1024>::new(n, d)), comment))
+        } else {
+            let d = U512::from_bytes(&dbuf);
+            let n = U512::from_bytes(&nbuf);
+            Ok((RSAPrivate::Key512(RSAPrivateKey::<U512>::new(n, d)), comment))
+        }
+    }
+
+    fn render_ssh_public_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        render_openssh_string(out, "ssh-rsa")?;
+        match self {
+            RSAPair::R512(pbl,_) => {
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &pbl.n)?;
+            }
+            RSAPair::R1024(pbl,_) => {
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &pbl.n)?;
+            }
+            RSAPair::R2048(pbl,_) => {
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &pbl.n)?;
+            }
+            RSAPair::R3072(pbl,_) => {
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &pbl.n)?;
+            }
+            RSAPair::R4096(pbl,_) => {
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &pbl.n)?;
+            }
+            RSAPair::R8192(pbl,_) => {
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &pbl.n)?;
+            }
+            RSAPair::R15360(pbl,_) => {
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &pbl.n)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn render_ssh_private_info<O: Write>(&self, out: &mut O) -> Result<(),SSHKeyRenderError>
+    {
+        render_openssh_string(out, "ssh-rsa")?;
+        match self {
+            RSAPair::R512(pbl,prv) => {
+                render_openssh_number(out, &pbl.n)?;
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &prv.d)?;
+            }
+            RSAPair::R1024(pbl,prv) => {
+                render_openssh_number(out, &pbl.n)?;
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &prv.d)?;
+            }
+            RSAPair::R2048(pbl,prv) => {
+                render_openssh_number(out, &pbl.n)?;
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &prv.d)?;
+            }
+            RSAPair::R3072(pbl,prv) => {
+                render_openssh_number(out, &pbl.n)?;
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &prv.d)?;
+            }
+            RSAPair::R4096(pbl,prv) => {
+                render_openssh_number(out, &pbl.n)?;
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &prv.d)?;
+            }
+            RSAPair::R8192(pbl,prv) => {
+                render_openssh_number(out, &pbl.n)?;
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &prv.d)?;
+            }
+            RSAPair::R15360(pbl,prv) => {
+                render_openssh_number(out, &pbl.n)?;
+                render_openssh_number(out, &pbl.e)?;
+                render_openssh_number(out, &prv.d)?;
+            }
+        }
+        /* iqmp */ render_openssh_buffer(out, &vec![])?;
+        /* p    */ render_openssh_buffer(out, &vec![])?;
+        /* q    */ render_openssh_buffer(out, &vec![])?;
+        Ok(())
+    }
+}

src/testing.rs

@@ -23,11 +23,11 @@ fn next_value_set(line: &str) -> (String, bool, Vec<u8>)
     while let Some(c1) = nibble_iter.next() {
         match nibble_iter.next() {
             None => {
-                val.push( c1.to_digit(16).unwrap() as u8 );
+                val.push( c1.to_digit(16).expect(&format!("Unexpected character: |{}|", c1)) as u8 );
             }
             Some(c2) => {
-                let b1 = c1.to_digit(16).unwrap() as u8;
+                let b1 = c1.to_digit(16).expect(&format!("Unexpected character: |{}|", c1)) as u8;
-                let b2 = c2.to_digit(16).unwrap() as u8;
+                let b2 = c2.to_digit(16).expect(&format!("Unexpected character: |{}|", c2)) as u8;
                 val.push( (b2 << 4) | b1 );
             }
         }

src/x509/algident.rs

@@ -2,12 +2,28 @@ use num::BigUint;
 use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,FromASN1,OID,ToASN1};
 use x509::error::X509ParseError;
 
+/// A supported x509 hash algorithm
 #[derive(Clone,Copy,Debug,PartialEq)]
 pub enum HashAlgorithm { SHA1, SHA224, SHA256, SHA384, SHA512 }
 
+/// A supported x509 asymmetric crypto algorithm
 #[derive(Clone,Copy,Debug,PartialEq)]
 pub enum PublicKeyInfo { RSA, DSA, ECDSA }
 
+/// The algorithm used, either in a certificate or as part of the signing
+/// process. We only actually support a subset of the possible values,
+/// here, although we try to catch them all.
+/// 
+/// Specifically, this library supports:
+/// 
+///   |          | *RSA* | *DSA* | *ECDSA* |
+///   |----------|-------|-------|---------|
+///   | *SHA1*   |   X   |   X   |    X    |
+///   | *SHA224* |   X   |   X   |    X    |
+///   | *SHA256* |   X   |   X   |    X    |
+///   | *SHA384* |   X   |       |    X    |
+///   | *SHA512* |   X   |       |    X    |
+/// 
 #[derive(Clone,Debug,PartialEq)]
 pub struct AlgorithmIdentifier {
     pub hash: HashAlgorithm,

src/x509/atv.rs

@@ -1,11 +1,13 @@
 use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,FromASN1,ToASN1};
 use std::ops::Index;
 use x509::error::X509ParseError;
-use x509::name::X520Name;
+pub use x509::name::X520Name;
 
+/// All of the various bits of information that are encoded within an x.509
+/// certificate.
 #[derive(Clone,Debug)]
 pub struct InfoBlock {
-    fields: Vec<AttributeTypeValue>
+    pub fields: Vec<AttributeTypeValue>
 }
 
 const EMPTY_STRING: &'static str = "";
@@ -116,11 +118,11 @@ impl ToASN1 for InfoBlock {
     }
 }
 
-
+/// An attribute within an x.509 key and its associated string value.
 #[derive(Clone,Debug,PartialEq)]
-struct AttributeTypeValue {
+pub struct AttributeTypeValue {
-    attrtype: X520Name,
+    pub attrtype: X520Name,
-    value:    String
+    pub value:    String
 }
 
 fn decode_attribute_type_value(x: &ASN1Block)

src/x509/misc.rs

@@ -3,6 +3,7 @@ use num::bigint::ToBigInt;
 use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,FromASN1,ToASN1};
 use x509::error::X509ParseError;
 
+/// Which version of x.509 certificate this is.
 #[derive(Clone,Copy,Debug,PartialEq)]
 pub enum X509Version { V1, V2, V3 }
 
@@ -65,6 +66,7 @@ impl ToASN1 for X509Version {
 
 /******************************************************************************/
 
+/// The serial number for this certificate.
 #[derive(Clone,Debug,PartialEq)]
 pub struct X509Serial {
     num: BigUint

src/x509/mod.rs

@@ -6,19 +6,20 @@ mod name;
 mod publickey;
 mod validity;
 
-use dsa::{DSAPublic,DSAPublicKey};
+use dsa::DSAPublic;
-use ecdsa::{ECDSAPublic,ECCPublicKey};
+use ecdsa::ECDSAPublic;
 use rsa::{SIGNING_HASH_SHA1,SIGNING_HASH_SHA224,SIGNING_HASH_SHA256,SIGNING_HASH_SHA384,SIGNING_HASH_SHA512};
 use sha1::Sha1;
 use sha2::{Sha224,Sha256,Sha384,Sha512};
 use simple_asn1::{ASN1Block,FromASN1,der_decode,from_der};
-use x509::validity::Validity;
+pub use x509::validity::Validity;
-use x509::algident::{AlgorithmIdentifier,HashAlgorithm,PublicKeyInfo,
+pub use x509::algident::{AlgorithmIdentifier,HashAlgorithm,PublicKeyInfo};
-                     decode_algorithm_ident};
+use x509::algident::{decode_algorithm_ident};
-use x509::atv::InfoBlock;
+pub use x509::atv::InfoBlock;
 use x509::error::X509ParseError;
-use x509::misc::{X509Serial,X509Version,decode_signature};
+pub use x509::misc::{X509Serial,X509Version};
-use x509::publickey::X509PublicKey;
+use x509::misc::{decode_signature};
+pub use x509::publickey::X509PublicKey;
 
 /*******************************************************************************
  *
@@ -59,21 +60,13 @@ fn decode_certificate(x: &ASN1Block)
     //
     match x {
         &ASN1Block::Sequence(_, _, ref b0) => {
-            println!("STEP1");
             let (version,  b1) = X509Version::from_asn1(b0)?;
-            println!("STEP2");
             let (serial,   b2) = X509Serial::from_asn1(b1)?;
-            println!("STEP3");
             let (ident,    b3) = AlgorithmIdentifier::from_asn1(b2)?;
-            println!("STEP4");
             let (issuer,   b4) = InfoBlock::from_asn1(b3)?;
-            println!("STEP5");
             let (validity, b5) = Validity::from_asn1(b4)?;
-            println!("STEP6");
             let (subject,  b6) = InfoBlock::from_asn1(b5)?;
-            println!("STEP7");
             let (subkey,   _ ) = X509PublicKey::from_asn1(b6)?;
-            println!("STEP8");
             Ok(GenericCertificate {
                 version: version,
                 serial: serial,
@@ -96,6 +89,8 @@ fn decode_certificate(x: &ASN1Block)
  *
  ******************************************************************************/
 
+/// Parse an X.590 certificate in memory into a generic certificate that can
+/// be used by a program.
 pub fn parse_x509(buffer: &[u8]) -> Result<GenericCertificate,X509ParseError> {
     let blocks = from_der(&buffer[..])?;
     match blocks.first() {
@@ -190,7 +185,7 @@ fn check_signature(alg: &AlgorithmIdentifier,
                     Err(X509ParseError::InvalidSignatureHash)
             }
         }
-        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::ECCPublicP192(ref key))) => {
+        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::P192(ref key))) => {
             let ecdsa_sig = der_decode(&sig)?;
             match alg.hash {
                 HashAlgorithm::SHA1   if key.verify::<Sha1>(block, &ecdsa_sig)   => Ok(()),
@@ -202,7 +197,7 @@ fn check_signature(alg: &AlgorithmIdentifier,
                     Err(X509ParseError::InvalidSignatureHash)
             }
         }
-        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::ECCPublicP224(ref key))) => {
+        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::P224(ref key))) => {
             let ecdsa_sig = der_decode(&sig)?;
             match alg.hash {
                 HashAlgorithm::SHA1   if key.verify::<Sha1>(block, &ecdsa_sig)   => Ok(()),
@@ -214,7 +209,7 @@ fn check_signature(alg: &AlgorithmIdentifier,
                     Err(X509ParseError::InvalidSignatureHash)
             }
         }
-        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::ECCPublicP256(ref key))) => {
+        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::P256(ref key))) => {
             let ecdsa_sig = der_decode(&sig)?;
             match alg.hash {
                 HashAlgorithm::SHA1   if key.verify::<Sha1>(block, &ecdsa_sig)   => Ok(()),
@@ -226,7 +221,7 @@ fn check_signature(alg: &AlgorithmIdentifier,
                     Err(X509ParseError::InvalidSignatureHash)
             }
         }
-        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::ECCPublicP384(ref key))) => {
+        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::P384(ref key))) => {
             let ecdsa_sig = der_decode(&sig)?;
             match alg.hash {
                 HashAlgorithm::SHA1   if key.verify::<Sha1>(block, &ecdsa_sig)   => Ok(()),
@@ -238,7 +233,7 @@ fn check_signature(alg: &AlgorithmIdentifier,
                     Err(X509ParseError::InvalidSignatureHash)
             }
         }
-        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::ECCPublicP521(ref key))) => {
+        (PublicKeyInfo::ECDSA, &X509PublicKey::ECDSA(ECDSAPublic::P521(ref key))) => {
             let ecdsa_sig = der_decode(&sig)?;
             match alg.hash {
                 HashAlgorithm::SHA1   if key.verify::<Sha1>(block, &ecdsa_sig)   => Ok(()),

src/x509/name.rs

@@ -2,6 +2,8 @@ use num::BigUint;
 use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,FromASN1,OID,ToASN1};
 use x509::error::X509ParseError;
 
+/// One of the various attributes that can be encoded within an x.509 name. To
+/// see one of these paired with its value, consider `AttributeTypeValue`.
 #[derive(Copy,Clone,Debug,Eq,Hash,PartialEq)]
 pub enum X520Name {
     Name, Surname, GivenName, Initials, GenerationQualifier, CommonName,

src/x509/publickey.rs

@@ -1,8 +1,8 @@
 use cryptonum::unsigned::{U3072,U2048,U1024,U256,U192};
-use dsa::{DSAPublic,DSAPublicKey,DSAPubKey,DSAParameters};
+use dsa::{DSAPublic,DSAPublicKey,DSAParameters};
 use dsa::{L3072N256,L2048N256,L2048N224,L1024N160};
-use ecdsa::{ECDSAEncodeErr,ECDSAPublic,ECCPubKey};
+use ecdsa::{ECDSAEncodeErr,ECDSAPublic,ECCPublicKey};
-use ecdsa::curve::{P192,P224,P256,P384,P521};
+use ecdsa::{P192,P224,P256,P384,P521};
 use num::BigUint;
 use rsa::RSAPublic;
 use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,FromASN1,OID,ToASN1,
@@ -10,6 +10,8 @@ use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,FromASN1,OID,ToASN1,
 use utils::TranslateNums;
 use x509::error::X509ParseError;
 
+/// A general type that includes all the supported public key types that we
+/// could read in an x.509 certificate.
 pub enum X509PublicKey {
     DSA(DSAPublic),
     RSA(RSAPublic),
@@ -174,7 +176,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
                 let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
                 if let ASN1Block::Integer(_,_,ynum) = iblk {
                     let y = U3072::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
-                    let key = DSAPubKey::<L3072N256,U3072>::new(params, y);
+                    let key = DSAPublicKey::<L3072N256>::new(params, y);
                     let reskey = DSAPublic::DSAPublicL3072N256(key);
                     return Ok(reskey);
                 }
@@ -195,7 +197,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
                     let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
                     if let ASN1Block::Integer(_,_,ynum) = iblk {
                         let y = U2048::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
-                        let key = DSAPubKey::<L2048N256,U2048>::new(params, y);
+                        let key = DSAPublicKey::<L2048N256>::new(params, y);
                         let reskey = DSAPublic::DSAPublicL2048N256(key);
                         return Ok(reskey);
                     }
@@ -213,7 +215,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
                     let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
                     if let ASN1Block::Integer(_,_,ynum) = iblk {
                         let y = U2048::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
-                        let key = DSAPubKey::<L2048N224,U2048>::new(params, y);
+                        let key = DSAPublicKey::<L2048N224>::new(params, y);
                         let reskey = DSAPublic::DSAPublicL2048N224(key);
                         return Ok(reskey);
                     }
@@ -233,7 +235,7 @@ fn decode_dsa_key(info: ASN1Block, key: &ASN1Block) -> Result<DSAPublic,X509Pars
             let (iblk,_) = blocks.split_first().ok_or(X509ParseError::InvalidDSAKey)?;
             if let ASN1Block::Integer(_,_,ynum) = iblk {
                 let y = U1024::from_num(ynum).ok_or(X509ParseError::InvalidDSAKey)?;
-                let key = DSAPubKey::<L1024N160,U1024>::new(params, y);
+                let key = DSAPublicKey::<L1024N160>::new(params, y);
                 let reskey = DSAPublic::DSAPublicL1024N160(key);
                 return Ok(reskey);
             }
@@ -255,11 +257,11 @@ fn encode_ecdsa_key(c: ASN1Class, x: &ECDSAPublic) -> Result<ASN1Block,ECDSAEnco
 {
     let objoid = ASN1Block::ObjectIdentifier(c, 0, oid!(1,2,840,10045,2,1));
     let (base_curve_oid, mut keyvec) = match x {
-        ECDSAPublic::ECCPublicP192(k) => (oid!(1,2,840,10045,3,1,1), k.to_asn1_class(c)?),
+        ECDSAPublic::P192(k) => (oid!(1,2,840,10045,3,1,1), k.to_asn1_class(c)?),
-        ECDSAPublic::ECCPublicP224(k) => (oid!(1,3,132,0,33), k.to_asn1_class(c)?),
+        ECDSAPublic::P224(k) => (oid!(1,3,132,0,33), k.to_asn1_class(c)?),
-        ECDSAPublic::ECCPublicP256(k) => (oid!(1,2,840,10045,3,1,7), k.to_asn1_class(c)?),
+        ECDSAPublic::P256(k) => (oid!(1,2,840,10045,3,1,7), k.to_asn1_class(c)?),
-        ECDSAPublic::ECCPublicP384(k) => (oid!(1,3,132,0,34), k.to_asn1_class(c)?),
+        ECDSAPublic::P384(k) => (oid!(1,3,132,0,34), k.to_asn1_class(c)?),
-        ECDSAPublic::ECCPublicP521(k) => (oid!(1,3,132,0,35), k.to_asn1_class(c)?),
+        ECDSAPublic::P521(k) => (oid!(1,3,132,0,35), k.to_asn1_class(c)?),
     };
     let curve_oid = ASN1Block::ObjectIdentifier(c, 0, base_curve_oid);
     let header = ASN1Block::Sequence(c, 0, vec![objoid, curve_oid]);
@@ -271,28 +273,28 @@ fn decode_ecdsa_key(info: ASN1Block, keybls: &[ASN1Block]) -> Result<ECDSAPublic
 {
     if let ASN1Block::ObjectIdentifier(_, _, oid) = info {
         if oid == oid!(1,2,840,10045,3,1,1) {
-            let (res, _) = ECCPubKey::<P192>::from_asn1(keybls)?;
+            let (res, _) = ECCPublicKey::<P192>::from_asn1(keybls)?;
-            return Ok(ECDSAPublic::ECCPublicP192(res));
+            return Ok(ECDSAPublic::P192(res));
         }
 
         if oid == oid!(1,3,132,0,33) {
-            let (res, _) = ECCPubKey::<P224>::from_asn1(keybls)?;
+            let (res, _) = ECCPublicKey::<P224>::from_asn1(keybls)?;
-            return Ok(ECDSAPublic::ECCPublicP224(res));
+            return Ok(ECDSAPublic::P224(res));
         }
 
         if oid == oid!(1,2,840,10045,3,1,7) {
-            let (res, _) = ECCPubKey::<P256>::from_asn1(keybls)?;
+            let (res, _) = ECCPublicKey::<P256>::from_asn1(keybls)?;
-            return Ok(ECDSAPublic::ECCPublicP256(res));
+            return Ok(ECDSAPublic::P256(res));
         }
 
         if oid == oid!(1,3,132,0,34) {
-            let (res, _) = ECCPubKey::<P384>::from_asn1(keybls)?;
+            let (res, _) = ECCPublicKey::<P384>::from_asn1(keybls)?;
-            return Ok(ECDSAPublic::ECCPublicP384(res));
+            return Ok(ECDSAPublic::P384(res));
         }
 
         if oid == oid!(1,3,132,0,35) {
-            let (res, _) = ECCPubKey::<P521>::from_asn1(keybls)?;
+            let (res, _) = ECCPublicKey::<P521>::from_asn1(keybls)?;
-            return Ok(ECDSAPublic::ECCPublicP521(res));
+            return Ok(ECDSAPublic::P521(res));
         }
     }
 

src/x509/validity.rs

@@ -2,10 +2,11 @@ use chrono::{DateTime,Utc};
 use simple_asn1::{ASN1Block,ASN1Class,ASN1EncodeErr,FromASN1,ToASN1};
 use x509::error::X509ParseError;
 
+/// The range of dates in which this certificate is valid.
 #[derive(Clone,Debug,PartialEq)]
 pub struct Validity {
-    not_before: DateTime<Utc>,
+    pub not_before: DateTime<Utc>,
-    not_after:  DateTime<Utc>
+    pub not_after:  DateTime<Utc>
 }
 
 fn decode_validity_data(bs: &ASN1Block) -> Result<Validity,X509ParseError> {

test-generator/DSA.hs

@@ -0,0 +1,84 @@
+{-# LANGUAGE PackageImports #-}
+module DSA(dsaTasks)
+ where
+
+import Codec.Crypto.DSA.Pure
+import Crypto.Hash(Digest, SHA256, hash)
+import "cryptonite" Crypto.Random(DRG(..),getRandomBytes,withDRG)
+import Data.ByteArray(convert)
+import qualified Data.ByteString as BS
+import Data.ByteString.Lazy(ByteString)
+import qualified Data.ByteString.Lazy as BSL
+import qualified Data.Map.Strict as Map
+import Math(showX,showBin)
+import Task(Task(..),liftTest)
+import Utils(HashAlg(..),generateHash,showHash)
+
+dsaSizes :: [(ParameterSizes, Int)]
+dsaSizes = [(L1024_N160, 400),
+            (L2048_N224, 100),
+            (L2048_N256,  50),
+            (L3072_N256,  25)]
+
+dsaTasks :: [Task]
+dsaTasks = concatMap generateTask dsaSizes
+
+generateTask :: (ParameterSizes, Int) -> [Task]
+generateTask (s, c) = [signTest s c]
+
+showParam :: ParameterSizes -> String
+showParam L1024_N160 = "L1024N160"
+showParam L2048_N224 = "L2048N224"
+showParam L2048_N256 = "L2048N256"
+showParam L3072_N256 = "L3072N256"
+
+signTest :: ParameterSizes -> Int -> Task
+signTest sz cnt = Task {
+    taskName = "DSA " ++ show sz ++ " signing",
+    taskFile = "../testdata/dsa/sign" ++ showParam sz ++ ".test",
+    taskTest = liftTest go,
+    taskCount = cnt
+  }
+ where
+  go (memory, drg0) =
+    case generateProbablePrimes sz drg0 sha256 Nothing of
+      Left _ -> goAdvance memory drg0
+      Right (p, q, _, drg1) ->
+        case generateUnverifiableGenerator p q of
+          Nothing -> goAdvance memory drg1
+          Just g ->
+            let params = Params p g q
+            in case generateKeyPairWithParams params drg1 of
+                 Left _ -> goAdvance memory drg1
+                 Right (pub, priv, drg2) ->
+                   let (msg, drg3) = withDRG drg2 $ getRandomBytes =<< ((fromIntegral . BS.head) `fmap` getRandomBytes 1)
+                       (hashf, drg4) = withDRG drg3 generateHash
+                   in case signMessage' (translateHash hashf) kViaRFC6979 drg4 priv (BSL.fromStrict msg) of
+                        Left _ ->
+                          go (memory, drg4)
+                        Right (sig, drg5) ->
+                          let res = Map.fromList [("p", showX p),
+                                                  ("q", showX q),
+                                                  ("g", showX g),
+                                                  ("y", showX (public_y pub)),
+                                                  ("x", showX (private_x priv)),
+                                                  ("m", showBin msg),
+                                                  ("h", showHash hashf),
+                                                  ("r", showX (sign_r sig)),
+                                                  ("s", showX (sign_s sig))]
+                          in (res, p, (memory, drg5))
+  --
+  goAdvance memory drg0 =
+    let (bstr, drg1) = randomBytesGenerate 37 drg0
+    in BS.null bstr `seq` go (memory, drg1)
+  --
+  translateHash Sha224 = Codec.Crypto.DSA.Pure.SHA224
+  translateHash Sha256 = Codec.Crypto.DSA.Pure.SHA256
+  translateHash Sha384 = Codec.Crypto.DSA.Pure.SHA384
+  translateHash Sha512 = Codec.Crypto.DSA.Pure.SHA512
+
+sha256 :: ByteString -> ByteString
+sha256 = BSL.fromStrict . convert' . hash . BSL.toStrict
+ where
+  convert' :: Digest SHA256 -> BS.ByteString
+  convert' = convert

test-generator/Database.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE PackageImports #-}
 module Database(
          Database,
          emptyDatabase,
@@ -5,15 +6,23 @@ module Database(
        )
  where
 
-import           Crypto.Random(DRG(..),SystemDRG)
+import "crypto-api" Crypto.Random(CryptoRandomGen(..),SystemRandom)
-import           Data.Bits(shiftL,testBit)
+import "cryptonite" Crypto.Random(DRG(..))
-import qualified Data.ByteString as S
+import              Data.ByteArray(convert)
-import           Data.Map.Strict(Map)
+import              Data.Bits(shiftL,testBit)
-import qualified Data.Map.Strict as Map
+import qualified    Data.ByteString as S
+import              Data.Map.Strict(Map)
+import qualified    Data.Map.Strict as Map
 
-type Database = (Map String [Integer], SystemDRG)
+type Database = (Map String [Integer], SystemRandom)
 
-emptyDatabase :: SystemDRG -> Database
+instance DRG SystemRandom where
+   randomBytesGenerate x g =
+     case genBytes x g of
+       Left e -> error ("Data generation error: " ++ show e)
+       Right (res, g') -> (convert res, g')
+
+emptyDatabase :: SystemRandom -> Database
 emptyDatabase g0 = (Map.empty, g0)
 
 generateNum :: Database -> String -> Int -> (Integer, Database)
@@ -27,7 +36,7 @@ generateNum (db, rng0) varname size =
 
 genSign :: (Integer, Database) -> (Integer, Database)
 genSign (x, (db, rng0)) =
-  let (n, rng1) = randomBytesGenerate 0 rng0
+  let (n, rng1) = randomBytesGenerate 1 rng0
       n' = integerize n 
   in if testBit n' 0 then (0 - x, (db, rng1)) else (x, (db, rng1))
 

test-generator/ECDSATesting.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE PackageImports #-}
 module ECDSATesting(
           ecdsaTasks
        )
@@ -9,12 +10,12 @@ import Crypto.PubKey.ECC.ECDSA(PrivateKey(..),PublicKey(..),Signature(..),signWi
 import Crypto.PubKey.ECC.Generate(generate)
 import Crypto.PubKey.ECC.Prim(scalarGenerate,pointAdd,pointNegate,pointDouble,pointBaseMul,pointMul,pointAddTwoMuls)
 import Crypto.PubKey.ECC.Types(Curve,CurveName(..),Point(..),common_curve,curveSizeBits,ecc_n,getCurveByName)
-import Crypto.Random(DRG(..),getRandomBytes,withDRG)
+import "cryptonite" Crypto.Random(DRG(..),getRandomBytes,withDRG)
 import qualified Data.ByteString as S
 import qualified Data.Map.Strict as Map
 import Math(showX,showBin)
 import RFC6979(generateKStream)
-import Task(Task(..))
+import Task(Task(..),liftTest)
 import Utils(HashAlg(..),generateHash,runHash,showHash)
 
 curves :: [(String, Curve)]
@@ -28,7 +29,7 @@ negateTest :: String -> Curve -> Task
 negateTest name curve = Task {
     taskName = name ++ " point negation",
     taskFile = "../testdata/ecc/negate/" ++ name ++ ".test",
-    taskTest = go,
+    taskTest = liftTest go,
     taskCount = 1000
 }
  where
@@ -48,7 +49,7 @@ doubleTest :: String -> Curve -> Task
 doubleTest name curve = Task {
     taskName = name ++ " point doubling",
     taskFile = "../testdata/ecc/double/" ++ name ++ ".test",
-    taskTest = go,
+    taskTest = liftTest go,
     taskCount = 1000
 }
  where
@@ -68,7 +69,7 @@ addTest :: String -> Curve -> Task
 addTest name curve = Task {
     taskName = name ++ " point addition",
     taskFile = "../testdata/ecc/add/" ++ name ++ ".test",
-    taskTest = go,
+    taskTest = liftTest go,
     taskCount = 1000
 }
  where
@@ -91,7 +92,7 @@ scaleTest :: String -> Curve -> Task
 scaleTest name curve = Task {
     taskName = name ++ " point scaling",
     taskFile = "../testdata/ecc/scale/" ++ name ++ ".test",
-    taskTest = go,
+    taskTest = liftTest go,
     taskCount = 1000
 }
  where
@@ -116,7 +117,7 @@ addScaleTest :: String -> Curve -> Task
 addScaleTest name curve = Task {
     taskName = name ++ " point addition of two scalings",
     taskFile = "../testdata/ecc/add_scale2/" ++ name ++ ".test",
-    taskTest = go,
+    taskTest = liftTest go,
     taskCount = 1000
 }
  where
@@ -143,7 +144,7 @@ signTest :: String -> Curve -> Task
 signTest name curve = Task {
     taskName = name ++ " curve signing",
     taskFile = "../testdata/ecc/sign/" ++ name ++ ".test",
-    taskTest = go,
+    taskTest = liftTest go,
     taskCount = 1000
 }
  where

test-generator/ED25519.hs

@@ -0,0 +1,735 @@
+{-# LANGUAGE PackageImports #-}
+module ED25519(ed25519Tasks)
+ where
+
+import Control.Monad(unless)
+import Crypto.Error(CryptoFailable(CryptoPassed))
+import "crypto-api" Crypto.Random(SystemRandom)
+import "cryptonite" Crypto.Random(getRandomBytes,withDRG)
+import Crypto.PubKey.Ed25519
+import Data.ByteArray(convert)
+import Data.ByteString(ByteString,pack,useAsCString)
+import qualified Data.ByteString as BS
+import Data.Int(Int32)
+import qualified Data.Map.Strict as Map
+import Data.Word(Word8,Word32,Word64)
+import ED25519.PrecompPoints
+import Foreign.C.Types(CChar)
+import Foreign.Marshal.Alloc(alloca)
+import Foreign.Marshal.Array(allocaArray,peekArray,pokeArray)
+import Foreign.Ptr(Ptr,castPtr)
+import Foreign.Storable(Storable(..))
+import Math(showX,showBin)
+import Task(Task(..))
+
+cTEST_COUNT :: Int
+cTEST_COUNT = 1000
+
+ed25519Tasks :: [Task]
+ed25519Tasks = [ loadTests, byteTests, addsubTests, mulTests,
+                  squaringTests, inversionTests, negateTests,
+                  cmovTests, isTests, square2Tests,
+                  pow22523Tests, fbvTests, conversionTests,
+                  ptDoubleTests, maddsubTests, ptAddSubTests,
+                  scalarMultBaseTests, slideTests, scalarMultTests,
+                  reduceTests, muladdTests, pubPrivTests,
+                  signTest ]
+
+loadTests :: Task
+loadTests = Task {
+    taskName = "ed25519 byte loading",
+    taskFile = "../testdata/ed25519/load.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) = 
+    do let (bytes, drg1) = withDRG drg0 (getRandomBytes 4)
+       res3 <- useAsCString bytes (\ptr -> load_3 ptr)
+       res4 <- useAsCString bytes (\ptr -> load_4 ptr)
+       let res = Map.fromList [("x", showBin bytes), ("a", showX res3), ("b", showX res4)]
+       return (res, fromIntegral res4, (memory0, drg1))
+
+byteTests :: Task
+byteTests = Task {
+    taskName = "ed25519 byte / element conversion",
+    taskFile = "../testdata/ed25519/bytes.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPackedBytes drg0 $ \ ptra drg1 ->
+      alloca $ \ ptrc ->
+        allocaArray 32 $ \ rptr ->
+          do clearSpace ptrc
+             pokeArray (rptr :: Ptr Word8) (replicate 32 0)
+             fe_frombytes ptrc ptra
+             b <- convertFE ptrc
+             fe_tobytes (castPtr rptr) ptrc
+             start <- peek ptra
+             end   <- peek (castPtr rptr)
+             unless (start == end) $
+               fail "field element tobytes/frombytes doesn't round trip"
+             bytes' <- pack `fmap` peekArray 32 (castPtr ptra :: Ptr Word8)
+             let res = Map.fromList [("a", showBin bytes'),
+                                     ("b", showBin b)]
+             return (res, toNumber b, (memory0, drg1))
+
+addsubTests :: Task
+addsubTests = Task {
+    taskName = "ed25519 addition/subtraction tests",
+    taskFile = "../testdata/ed25519/addsub.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ ptrel1 drg1 ->
+      randomElement drg1 $ \ ptrel2 drg2 ->
+        alloca $ \ ptrc ->
+          alloca $ \ ptrd ->
+            do fe_add ptrc ptrel1 ptrel2
+               fe_sub ptrd ptrel1 ptrel2
+               [a, b, c, d] <- mapM convertFE [ptrel1, ptrel2, ptrc, ptrd] 
+               let res = Map.fromList [("a", showBin a),
+                                       ("b", showBin b),
+                                       ("c", showBin c),
+                                       ("d", showBin d)]
+               return (res, toNumber c, (memory0, drg2))
+
+mulTests :: Task
+mulTests = Task {
+    taskName = "ed25519 multiplication tests",
+    taskFile = "../testdata/ed25519/mul.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ ptrel1 drg1 ->
+      randomElement drg1 $ \ ptrel2 drg2 ->
+        alloca $ \ ptrc ->
+          do fe_mul ptrc ptrel1 ptrel2
+             [a, b, c] <- mapM convertFE [ptrel1, ptrel2, ptrc] 
+             let res = Map.fromList [("a", showBin a),
+                                     ("b", showBin b),
+                                     ("c", showBin c)]
+             return (res, toNumber c, (memory0, drg2))
+
+squaringTests :: Task
+squaringTests = Task {
+    taskName = "ed25519 squaring tests",
+    taskFile = "../testdata/ed25519/square.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ ptrel drg1 ->
+      alloca $ \ ptrc ->
+        do fe_square ptrc ptrel
+           [a, c] <- mapM convertFE [ptrel, ptrc]
+           let res = Map.fromList [("a", showBin a),
+                                   ("c", showBin c)]
+           return (res, toNumber c, (memory0, drg1))
+
+inversionTests :: Task
+inversionTests = Task {
+    taskName = "ed25519 inversion tests",
+    taskFile = "../testdata/ed25519/invert.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ ptrel drg1 ->
+      alloca $ \ ptrc ->
+        do fe_invert ptrc ptrel
+           a <- convertFE ptrel
+           c <- convertFE ptrc
+           let res = Map.fromList [("a", showBin a),
+                                   ("c", showBin c)]
+           return (res, toNumber a, (memory0, drg1))
+
+negateTests :: Task
+negateTests = Task {
+    taskName = "ed25519 negation tests",
+    taskFile = "../testdata/ed25519/negate.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ ptrel drg1 ->
+      alloca $ \ ptrc ->
+        do fe_negate ptrc ptrel
+           a <- convertFE ptrel
+           c <- convertFE ptrc
+           let res = Map.fromList [("a", showBin a),
+                                   ("c", showBin c)]
+           return (res, toNumber a, (memory0, drg1))
+
+cmovTests :: Task
+cmovTests = Task {
+    taskName = "ed25519 conditional mov tests",
+    taskFile = "../testdata/ed25519/cmov.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ aelptr drg1 ->
+      do let (bbytes, drg2) = withDRG drg1 (getRandomBytes 1)
+             b              = even (BS.head bbytes)
+             bvalLib        = if b then 0 else 1
+             bvalOut        = if b then 0 else 0xFFFFFF :: Word32
+         alloca $ \ celptr ->
+           do clearSpace celptr
+              fe_cmov celptr aelptr bvalLib
+              a <- convertFE aelptr
+              c <- convertFE celptr
+              let res = Map.fromList [("a", showBin a),
+                                      ("b", showX   bvalOut),
+                                      ("c", showBin c)]
+              return (res, toNumber a, (memory0, drg2))
+
+isTests :: Task
+isTests = Task {
+    taskName = "ed25519 predicate tests",
+    taskFile = "../testdata/ed25519/istests.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ aptr drg1 ->
+      do a <- convertFE aptr
+         z <- fe_isnonzero aptr
+         n <- fe_isnegative aptr
+         let res = Map.fromList [("a", showBin a),
+                                 ("z", showX (if z == 0 then 0 :: Word32 else 0xFFFFFF)),
+                                 ("n", showX (if n == 0 then 0 :: Word32 else 0xFFFFFF))]
+         return (res, toNumber a, (memory0, drg1))
+
+square2Tests :: Task
+square2Tests = Task {
+    taskName = "ed25519 square2 tests",
+    taskFile = "../testdata/ed25519/square2.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) = 
+    randomElement drg0 $ \ aptr drg1 ->
+      alloca $ \ cptr ->
+        do clearSpace cptr
+           fe_square2 cptr aptr
+           a <- convertFE aptr
+           c <- convertFE cptr
+           let res = Map.fromList [("a", showBin a), ("c", showBin c)]
+           return (res, toNumber a, (memory0, drg1))
+
+pow22523Tests :: Task
+pow22523Tests = Task {
+    taskName = "ed25519 pow22523 tests",
+    taskFile = "../testdata/ed25519/pow22523.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomElement drg0 $ \ aptr drg1 ->
+      alloca $ \ cptr ->
+        do clearSpace cptr
+           fe_pow22523 cptr aptr
+           a <- convertFE aptr
+           c <- convertFE cptr
+           let res = Map.fromList [("a", showBin a), ("c", showBin c)]
+           return (res, toNumber a, (memory0, drg1))
+
+fbvTests :: Task
+fbvTests = Task {
+    taskName = "ed25519 from bytes (vartime) tests",
+    taskFile = "../testdata/ed25519/fbv.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    do let (abytes, drg1) = withDRG drg0 (getRandomBytes 32)
+       useAsCString abytes $ \ aptr ->
+         do let aptr' = castPtr aptr :: Ptr PackedBytes
+            curve25519_scalar_mask aptr'
+            alloca $ \ dest ->
+              do clearSpace dest
+                 ok <- point_frombytes dest aptr'
+                 a <- pack `fmap` peekArray 32 (castPtr aptr)
+                 c <- pack `fmap` peekArray (4 * 10 * 4) (castPtr dest)
+                 let c' | ok        = c
+                        | otherwise = BS.empty
+                 let res = Map.fromList [("a", showBin a),
+                                         ("b", showBin c'),
+                                         ("c", showBin c)]
+                 return (res, if ok then (toNumber abytes) else 0, (memory0, drg1))
+
+conversionTests :: Task
+conversionTests = Task {
+    taskName = "ed25519 point form conversion tests",
+    taskFile = "../testdata/ed25519/conversion.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPoint3 drg0 $ \ ptr3 drg' ->
+      alloca $ \ ptrCached ->
+        alloca $ \ ptr2 ->
+          alloca $ \ ptrP1P1 ->
+            alloca $ \ ptr2' ->
+              alloca $ \ ptr3' ->
+                do clearSpace ptrCached
+                   clearSpace ptr2
+                   clearSpace ptrP1P1
+                   clearSpace ptr2'
+                   clearSpace ptr3'
+                   p3_to_cached ptrCached ptr3
+                   ge_p3_to_p2  ptr2      ptr3
+                   ge_p3_dbl    ptrP1P1   ptr3
+                   p1p1_to_p2   ptr2'     ptrP1P1
+                   p1p1_to_p3   ptr3'     ptrP1P1
+                   a <- convertPoint ptr3
+                   c <- convertPoint ptrCached
+                   t <- convertPoint ptr2
+                   o <- convertPoint ptrP1P1
+                   d <- convertPoint ptr2'
+                   b <- convertPoint ptr3'
+                   let res = Map.fromList [("a", showBin a), ("c", showBin c),
+                                           ("t", showBin t), ("o", showBin o),
+                                           ("d", showBin d), ("b", showBin b)]
+                   return (res, toNumber a, (memory0, drg'))
+
+ptDoubleTests :: Task
+ptDoubleTests = Task {
+    taskName = "ed25519 point doubling tests",
+    taskFile = "../testdata/ed25519/pt_double.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPoint3 drg0 $ \ ptra drg1 ->
+      randomPoint2 drg1 $ \ ptrc drg2 ->
+        alloca $ \ ptrb ->
+          alloca $ \ ptrd ->
+            do clearSpace ptrb
+               clearSpace ptrd
+               ge_p3_dbl ptrb ptra
+               ge_p2_dbl ptrd ptrc
+               a <- convertPoint ptra
+               b <- convertPoint ptrb
+               c <- convertPoint ptrc
+               d <- convertPoint ptrd
+               let res = Map.fromList [("a", showBin a), ("b", showBin b),
+                                       ("c", showBin c), ("d", showBin d)]
+               return (res, toNumber a, (memory0, drg2))
+
+maddsubTests :: Task
+maddsubTests = Task {
+    taskName = "ed25519 point madd/msub tests",
+    taskFile = "../testdata/ed25519/maddsub.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPoint3 drg0 $ \ ptra drg1 ->
+      randomPointPrecomp drg1 $ \ ptrc drg2 ->
+        alloca $ \ ptrb ->
+          alloca $ \ ptrd ->
+            do clearSpace ptrb
+               clearSpace ptrd
+               ge_madd ptrb ptra ptrc
+               ge_msub ptrd ptra ptrc
+               a <- convertPoint ptra
+               b <- convertPoint ptrb
+               c <- convertPoint ptrc
+               d <- convertPoint ptrd
+               let res = Map.fromList [("a", showBin a), ("b", showBin b),
+                                       ("c", showBin c), ("d", showBin d)]
+               return (res, toNumber a, (memory0, drg2))
+
+ptAddSubTests :: Task
+ptAddSubTests = Task {
+    taskName = "ed25519 point add/sub tests",
+    taskFile = "../testdata/ed25519/ptaddsub.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPoint3 drg0 $ \ ptra drg1 ->
+      randomPointCached drg1 $ \ ptrc drg2 ->
+        alloca $ \ ptrb ->
+          alloca $ \ ptrd ->
+            do clearSpace ptrb
+               clearSpace ptrd
+               ge_add ptrb ptra ptrc
+               ge_sub ptrd ptra ptrc
+               a <- convertPoint ptra
+               b <- convertPoint ptrb
+               c <- convertPoint ptrc
+               d <- convertPoint ptrd
+               let res = Map.fromList [("a", showBin a), ("b", showBin b),
+                                       ("c", showBin c), ("d", showBin d)]
+               return (res, toNumber a, (memory0, drg2))
+
+scalarMultBaseTests :: Task
+scalarMultBaseTests = Task {
+    taskName = "ed25519 point add/sub tests",
+    taskFile = "../testdata/ed25519/scalar_mult.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPackedBytes drg0 $ \ ptra drg1 ->
+      alloca $ \ ptrb ->
+        do clearSpace ptrb
+           x25519_ge_scalarmult_base ptrb ptra
+           PB abytes <- peek ptra
+           let a = pack abytes
+           b <- convertPoint ptrb
+           let res = Map.fromList [("a", showBin a), ("b", showBin b)]
+           return (res, toNumber a, (memory0, drg1))
+
+slideTests :: Task
+slideTests = Task {
+    taskName = "ed25519 slide helper function tests",
+    taskFile = "../testdata/ed25519/slide.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPackedBytes drg0 $ \ ptra drg1 ->
+      allocaArray 256 $ \ ptrb ->
+        do pokeArray ptrb (replicate 256 0)
+           slide ptrb ptra
+           a <- pack `fmap` peekArray 32 (castPtr ptra)
+           b <- pack `fmap` peekArray 356 ptrb 
+           let res = Map.fromList [("a", showBin a), ("b", showBin b)]
+           return (res, toNumber a, (memory0, drg1))
+
+scalarMultTests :: Task
+scalarMultTests = Task {
+    taskName = "ed25519 point general scalar multiplication tests",
+    taskFile = "../testdata/ed25519/scalar_mult_gen.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPackedBytes drg0 $ \ ptra drg1 ->
+      randomPoint3 drg1 $ \ ptrb drg2 ->
+        randomPackedBytes drg2 $ \ ptrc drg3 ->
+          alloca $ \ ptrd ->
+            do clearSpace ptrd
+               ge_double_scalarmult_vartime ptrd ptra ptrb ptrc
+               PB abytes <- peek ptra
+               let a = pack abytes
+               b <- convertPoint ptrb
+               PB cbytes <- peek ptrc
+               let c = pack cbytes
+               d <- convertPoint ptrd
+               let res = Map.fromList [("a", showBin a), ("b", showBin b),
+                                       ("c", showBin c), ("d", showBin d)]
+               return (res, toNumber a, (memory0, drg3))
+
+reduceTests :: Task
+reduceTests = Task {
+    taskName = "ed25519 reduce tests",
+    taskFile = "../testdata/ed25519/reduce.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    do let (a, drg1) = withDRG drg0 (getRandomBytes 64)
+       allocaArray 64 $ \ target ->
+         do pokeArray target (BS.unpack a)
+            sc_reduce target
+            b <- pack `fmap` peekArray 32 target
+            let res = Map.fromList [("a", showBin a), ("b", showBin b)]
+            return (res, toNumber a, (memory0, drg1))
+
+muladdTests :: Task
+muladdTests = Task {
+    taskName = "ed25519 multiplication+addition tests",
+    taskFile = "../testdata/ed25519/muladd.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPackedBytes drg0 $ \ ptra drg1 ->
+      randomPackedBytes drg1 $ \ ptrb drg2 ->
+        randomPackedBytes drg2 $ \ ptrc drg3 ->
+          alloca $ \ ptrd ->
+            do clearSpace ptrd
+               sc_muladd ptrd ptra ptrb ptrc
+               a <- repackBytes ptra
+               b <- repackBytes ptrb
+               c <- repackBytes ptrc
+               d <- repackBytes ptrd
+               let res = Map.fromList [("a", showBin a), ("b", showBin b),
+                                       ("c", showBin c), ("d", showBin d)]
+               return (res, toNumber a, (memory0, drg3))
+
+pubPrivTests :: Task
+pubPrivTests = Task {
+    taskName = "ed25519 private -> public conversion tests",
+    taskFile = "../testdata/ed25519/pubfrompriv.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    randomPackedBytes drg0 $ \ ptra drg1 ->
+      alloca $ \ ptrb ->
+        do clearSpace ptrb
+           public_from_private ptrb ptra
+           a <- repackBytes ptra
+           b <- repackBytes ptrb
+           let res = Map.fromList [("a", showBin a), ("b", showBin b)]
+           return (res, toNumber a, (memory0, drg1))
+
+signTest :: Task
+signTest = Task {
+    taskName = "ed25519 signing tests",
+    taskFile = "../testdata/ed25519/sign.test",
+    taskTest = go,
+    taskCount = cTEST_COUNT
+  }
+ where
+  go (memory0, drg0) =
+    let (priv, drg1) = withDRG drg0 generateSecretKey
+        (msg, drg2) = withDRG drg1 $ getRandomBytes =<< ((fromIntegral . BS.head) `fmap` getRandomBytes 1)
+        pub = toPublic priv
+        privBytes = convert priv
+        pubBytes = convert pub
+        sig = convert (sign priv pub msg)
+        res = Map.fromList [("u", showBin pubBytes), ("r", showBin privBytes),
+                            ("m", showBin msg), ("s", showBin sig)]
+    in return (res, toNumber privBytes, (memory0, drg2))
+
+
+data PackedBytes = PB [Word8]
+ deriving (Eq)
+
+instance Storable PackedBytes where
+  sizeOf    _        = 32
+  alignment _        = 8
+  peek      p        = PB `fmap` peekArray 32 (castPtr p)
+  poke      p (PB v) = pokeArray    (castPtr p) v
+
+randomPackedBytes :: SystemRandom -> (Ptr PackedBytes -> SystemRandom -> IO a) -> IO a
+randomPackedBytes drg action =
+  do let (bytes, drg') = withDRG drg (getRandomBytes 32)
+     useAsCString bytes $ \ ptr ->
+       do let ptr' = castPtr ptr :: Ptr PackedBytes
+          curve25519_scalar_mask ptr'
+          action ptr' drg'
+
+repackBytes :: Ptr PackedBytes -> IO ByteString
+repackBytes ptr =
+  do PB xs <- peek ptr
+     return (pack xs)
+
+data Element = FE [Int32]
+
+instance Storable Element where
+  sizeOf    _        = 10 * sizeOf (undefined :: Int32)
+  alignment _        = 8
+  peek      p        = FE `fmap` peekArray 10 (castPtr p)
+  poke      p (FE v) = pokeArray (castPtr p) v
+
+randomElement :: SystemRandom -> (Ptr Element -> SystemRandom -> IO a) -> IO a
+randomElement drg action =
+  randomPackedBytes drg $ \ ptrpb drg' -> alloca $ \ ptrel ->
+    do clearSpace ptrel
+       fe_frombytes ptrel ptrpb
+       action ptrel drg'
+
+data Point3 = P3 [Element]
+
+instance Storable Point3 where
+  sizeOf    _        = 4 * sizeOf (undefined :: Element)
+  alignment _        = 8
+  peek      p        = P3 `fmap` peekArray 4 (castPtr p)
+  poke      p (P3 v) = pokeArray (castPtr p) v
+
+randomPoint3 :: SystemRandom -> (Ptr Point3 -> SystemRandom -> IO a) -> IO a
+randomPoint3 drg0 action = allocaArray (4 * 10) (go drg0)
+ where
+  go drg dest =
+    do mres <- randomPackedBytes drg $ \ aptr drg' ->
+                 do clearSpace dest
+                    worked <- point_frombytes dest aptr
+                    if worked
+                       then Right `fmap` action (castPtr dest) drg'
+                       else return (Left drg')
+       case mres of
+         Right x -> return x
+         Left drg' -> go drg' dest
+
+data PointCached = PC [Element]
+
+instance Storable PointCached where
+  sizeOf    _        = 4 * sizeOf (undefined :: Element)
+  alignment _        = 8
+  peek      p        = PC `fmap` peekArray 4 (castPtr p)
+  poke      p (PC v) = pokeArray (castPtr p) v
+
+randomPointCached :: SystemRandom -> (Ptr PointCached -> SystemRandom -> IO a) -> IO a
+randomPointCached drg action =
+  randomPoint3 drg $ \ ptr drg' ->
+    allocaArray (4 * 10) $ \ dest ->
+      do pokeArray (castPtr dest :: Ptr Int32) (replicate (4 * 10) 0)
+         p3_to_cached dest ptr
+         action (castPtr dest) drg'
+
+data Point2 = P2 [Element]
+
+instance Storable Point2 where
+  sizeOf    _        = 3 * sizeOf (undefined :: Element)
+  alignment _        = 8
+  peek      p        = P2 `fmap` peekArray 3 (castPtr p)
+  poke      p (P2 v) = pokeArray (castPtr p) v
+
+randomPoint2 :: SystemRandom -> (Ptr Point2 -> SystemRandom -> IO a) -> IO a
+randomPoint2 drg action =
+  randomPoint3 drg $ \ ptr3 drg' ->
+    allocaArray (3 * 10) $ \ dest ->
+      do pokeArray (castPtr dest :: Ptr Int32) (replicate (3 * 10) 0)
+         ge_p3_to_p2 dest ptr3
+         action (castPtr dest) drg'
+
+data PointP1P1 = P1P1 [Element]
+
+instance Storable PointP1P1 where
+  sizeOf    _          = 4 * sizeOf (undefined :: Element)
+  alignment _          = 8
+  peek      p          = P1P1 `fmap` peekArray 4 (castPtr p)
+  poke      p (P1P1 v) = pokeArray (castPtr p) v
+
+_randomPointP1P1 :: SystemRandom -> (Ptr PointP1P1 -> SystemRandom -> IO a) -> IO a
+_randomPointP1P1 drg action =
+  randomPoint3 drg $ \ ptr3 drg' ->
+    allocaArray (4 * 10) $ \ dest ->
+      do pokeArray (castPtr dest :: Ptr Int32) (replicate (4 * 10) 0)
+         ge_p3_dbl dest ptr3
+         action (castPtr dest) drg'
+
+data PointPrecomp = PP [Element]
+
+instance Storable PointPrecomp where
+  sizeOf    _        = 4 * sizeOf (undefined :: Element)
+  alignment _        = 8
+  peek      p        = PP `fmap` peekArray 4 (castPtr p)
+  poke      p (PP v) = pokeArray (castPtr p) v
+
+randomPointPrecomp :: SystemRandom -> (Ptr PointPrecomp -> SystemRandom -> IO a) -> IO a
+randomPointPrecomp drg action =
+  do let ([a,b,c,d], drg') = withDRG drg (BS.unpack `fmap` getRandomBytes 4)
+         mix = fromIntegral a + fromIntegral b + fromIntegral c + fromIntegral d
+         idx = mix `mod` (length precompPoints)
+         val = PP (map FE (precompPoints !! idx))
+     alloca $ \ ptr ->
+       do poke ptr val
+          action ptr drg'
+      
+clearSpace :: Storable a => Ptr a -> IO ()
+clearSpace x = meh x undefined
+ where
+  meh :: Storable a => Ptr a -> a -> IO ()
+  meh p v = pokeArray (castPtr p) (replicate (sizeOf v) (0 :: Word8))
+
+convertFE :: Ptr Element -> IO ByteString
+convertFE feptr = pack `fmap` peekArray 40 (castPtr feptr :: Ptr Word8)
+
+convertPoint :: Storable a => Ptr a -> IO ByteString
+convertPoint x = meh x undefined
+ where
+  meh :: Storable a => Ptr a -> a -> IO ByteString
+  meh p v = pack `fmap` peekArray (sizeOf v) (castPtr p)
+
+toNumber :: ByteString -> Integer
+toNumber = BS.foldr (\ x a -> fromIntegral x + a) 0
+
+foreign import ccall unsafe "load_3"
+  load_3 :: Ptr CChar -> IO Word64
+foreign import ccall unsafe "load_4"
+  load_4 :: Ptr CChar -> IO Word64
+foreign import ccall unsafe "GFp_curve25519_scalar_mask"
+  curve25519_scalar_mask :: Ptr PackedBytes -> IO ()
+foreign import ccall unsafe "fe_frombytes"
+  fe_frombytes :: Ptr Element -> Ptr PackedBytes -> IO ()
+foreign import ccall unsafe "GFp_fe_tobytes"
+  fe_tobytes :: Ptr PackedBytes -> Ptr Element -> IO ()
+foreign import ccall unsafe "fe_add"
+  fe_add :: Ptr Element -> Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "fe_sub"
+  fe_sub :: Ptr Element -> Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "GFp_fe_mul"
+  fe_mul :: Ptr Element -> Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "fe_sq"
+  fe_square :: Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "GFp_fe_invert"
+  fe_invert :: Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "fe_neg"
+  fe_negate :: Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "fe_cmov"
+  fe_cmov :: Ptr Element -> Ptr Element -> Word32 -> IO ()
+foreign import ccall unsafe "fe_isnonzero"
+  fe_isnonzero :: Ptr Element -> IO Int32
+foreign import ccall unsafe "GFp_fe_isnegative"
+  fe_isnegative :: Ptr Element -> IO Word8
+foreign import ccall unsafe "fe_sq2"
+  fe_square2 :: Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "fe_pow22523"
+  fe_pow22523 :: Ptr Element -> Ptr Element -> IO ()
+foreign import ccall unsafe "GFp_x25519_ge_frombytes_vartime"
+  point_frombytes :: Ptr Point3 -> Ptr PackedBytes -> IO Bool
+foreign import ccall unsafe "x25519_ge_p3_to_cached"
+  p3_to_cached :: Ptr PointCached -> Ptr Point3 -> IO ()
+foreign import ccall unsafe "x25519_ge_p1p1_to_p2"
+  p1p1_to_p2 :: Ptr Point2 -> Ptr PointP1P1 -> IO ()
+foreign import ccall unsafe "x25519_ge_p1p1_to_p3"
+  p1p1_to_p3 :: Ptr Point3 -> Ptr PointP1P1 -> IO ()
+foreign import ccall unsafe "ge_p2_dbl"
+  ge_p2_dbl :: Ptr PointP1P1 -> Ptr Point2 -> IO ()
+foreign import ccall unsafe "ge_p3_dbl"
+  ge_p3_dbl :: Ptr PointP1P1 -> Ptr Point3 -> IO ()
+foreign import ccall unsafe "ge_p3_to_p2"
+  ge_p3_to_p2 :: Ptr Point2 -> Ptr Point3 -> IO ()
+foreign import ccall unsafe "ge_madd"
+  ge_madd :: Ptr PointP1P1 -> Ptr Point3 -> Ptr PointPrecomp -> IO ()
+foreign import ccall unsafe "ge_msub"
+  ge_msub :: Ptr PointP1P1 -> Ptr Point3 -> Ptr PointPrecomp -> IO ()
+foreign import ccall unsafe "x25519_ge_add"
+  ge_add :: Ptr PointP1P1 -> Ptr Point3 -> Ptr PointCached -> IO ()
+foreign import ccall unsafe "x25519_ge_sub"
+  ge_sub :: Ptr PointP1P1 -> Ptr Point3 -> Ptr PointCached -> IO ()
+foreign import ccall unsafe "GFp_x25519_ge_scalarmult_base"
+  x25519_ge_scalarmult_base :: Ptr Point3 -> Ptr PackedBytes -> IO ()
+foreign import ccall unsafe "slide"
+  slide :: Ptr Word8 -> Ptr PackedBytes -> IO ()
+foreign import ccall unsafe "GFp_ge_double_scalarmult_vartime"
+  ge_double_scalarmult_vartime :: Ptr Point2 -> Ptr PackedBytes -> Ptr Point3 -> Ptr PackedBytes -> IO ()
+foreign import ccall unsafe "GFp_x25519_sc_reduce"
+  sc_reduce :: Ptr Word8 -> IO ()
+foreign import ccall unsafe "GFp_x25519_sc_muladd"
+  sc_muladd :: Ptr PackedBytes -> Ptr PackedBytes -> Ptr PackedBytes -> Ptr PackedBytes -> IO ()
+foreign import ccall unsafe "GFp_x25519_public_from_private"
+  public_from_private :: Ptr PackedBytes -> Ptr PackedBytes -> IO ()

test-generator/Main.hs

@@ -1,17 +1,21 @@
 {-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE PackageImports #-}
 import Control.Concurrent(forkIO)
 import Control.Concurrent.Chan(Chan,newChan,readChan,writeChan)
 import Control.Concurrent.MVar(MVar,newMVar,modifyMVar)
 import Control.Exception(SomeException,catch)
 import Control.Monad(replicateM_,void)
-import Crypto.Random(SystemDRG,getSystemDRG)
+import "crypto-api" Crypto.Random(CryptoRandomGen(..),SystemRandom)
+import DSA(dsaTasks)
 import ECDSATesting(ecdsaTasks)
+import ED25519(ed25519Tasks)
 import GHC.Conc(getNumCapabilities)
 import RFC6979(rfcTasks)
+import RSA(rsaTasks)
 import System.Console.AsciiProgress
 import Task(Task, runTask)
 
-taskExecutor :: MVar [Task] -> Chan () -> SystemDRG -> IO SystemDRG
+taskExecutor :: MVar [Task] -> Chan () -> SystemRandom -> IO SystemRandom
 taskExecutor taskList done gen =
     do mnext <- modifyMVar taskList (\case
                                        [] -> return ([], Nothing)
@@ -24,7 +28,7 @@ taskExecutor taskList done gen =
 
 spawnExecutor :: MVar [Task] -> Chan () -> IO ()
 spawnExecutor tasks done =
-  do gen <- getSystemDRG
+  do gen <- newGenIO
      void (forkIO (catch (void (taskExecutor tasks done gen)) handler))
  where
   handler :: SomeException -> IO ()
@@ -35,6 +39,6 @@ main = displayConsoleRegions $
     do 
        executors <- getNumCapabilities
        done <- newChan
-       tasks <- newMVar (ecdsaTasks ++ rfcTasks)
+       tasks <- newMVar (dsaTasks ++ ecdsaTasks ++ rfcTasks ++ rsaTasks ++ ed25519Tasks)
        replicateM_ executors (spawnExecutor tasks done)
        replicateM_ executors (void $ readChan done)

test-generator/RFC6979.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE PackageImports #-}
 module RFC6979
 --       (
 --         rfcTasks
@@ -7,14 +8,14 @@ module RFC6979
 import Crypto.Hash(SHA224(..),SHA256(..),SHA384(..),SHA512(..))
 import Crypto.MAC.HMAC(HMAC,hmac)
 import Crypto.Number.Generate(generateBetween)
-import Crypto.Random(getRandomBytes,withDRG)
+import "cryptonite" Crypto.Random(getRandomBytes,withDRG)
 import Data.Bits(shiftL,shiftR,(.&.))
 import qualified Data.ByteArray as B
 import qualified Data.ByteString as S
 import Data.Char(toUpper)
 import qualified Data.Map.Strict as Map
 import Math(showBin,showX)
-import Task(Task(..))
+import Task(Task(..),liftTest)
 import Utils(HashAlg(..), runHash)
 
 
@@ -87,7 +88,7 @@ rfc6979Test :: HashAlg -> Task
 rfc6979Test alg = Task {
     taskName = name ++ " RFC 6979 deterministic k-generation",
     taskFile = "../testdata/rfc6979/" ++ name ++ ".test",
-    taskTest = go,
+    taskTest = liftTest go,
     taskCount = 1000
 }
  where

test-generator/RSA.hs

@@ -0,0 +1,126 @@
+{-# LANGUAGE PackageImports #-}
+module RSA(rsaTasks)
+ where
+
+import Crypto.Hash(SHA224(..),SHA256(..),SHA384(..),SHA512(..))
+import "cryptonite" Crypto.Random(MonadRandom,MonadPseudoRandom,getRandomBytes,withDRG)
+import "crypto-api" Crypto.Random(SystemRandom)
+import Crypto.PubKey.MaskGenFunction(mgf1)
+import Crypto.PubKey.RSA
+import Crypto.PubKey.RSA.PKCS15(sign)
+import Crypto.PubKey.RSA.OAEP(OAEPParams(..),encrypt)
+import qualified Data.ByteString as BS
+import qualified Data.ByteString.Char8 as BSC
+import Data.Char(chr,isPrint)
+import Data.Map.Strict(Map)
+import qualified Data.Map.Strict as Map
+import Data.Maybe(fromMaybe,isJust)
+import Data.Word(Word8)
+import Database(Database)
+import Math(barrett,computeK,showX,showBin)
+import Task(Task(..),liftTest)
+import Utils(HashAlg(..),generateHash,showHash)
+
+rsaSizes :: [(Int, Int)]
+rsaSizes = [(512,  400),
+            (1024, 200),
+            (2048, 100),
+            (3072,  50),
+            (4096,  50),
+            (8192,  10),
+            (15360, 5)]
+
+rsaTasks :: [Task]
+rsaTasks = concatMap generateTask rsaSizes
+
+generateTask :: (Int, Int) -> [Task]
+generateTask (s, c) = [signTest s c, encryptTest s c]
+
+signTest :: Int -> Int -> Task
+signTest sz cnt = Task {
+    taskName = "RSA " ++ show sz ++ " signing",
+    taskFile = "../testdata/rsa/sign" ++ show sz ++ ".test",
+    taskTest = liftTest go,
+    taskCount = cnt
+  }
+ where
+  go db = withDRG' db go2
+  --
+  go2 :: MonadRandom m => m (Map String String, Integer)
+  go2 = do (public, private) <- generate (sz `div` 8) 65537
+           let d = private_d private
+           let n = public_n public
+           msg <- getRandomBytes =<< ((fromIntegral . BS.head) `fmap` getRandomBytes 1)
+           hash <- generateHash
+           case signWith hash private msg of
+             Left _ -> go2
+             Right sig -> return $ (Map.fromList [("d", showX d),
+                                                  ("n", showX n),
+                                                  ("k", showX (computeK n)),
+                                                  ("u", showX (barrett n)),
+                                                  ("h", showHash hash),
+                                                  ("m", showBin msg),
+                                                  ("s", showBin sig)], n)
+
+withDRG' :: Database -> MonadPseudoRandom SystemRandom (Map String String, Integer) ->
+            (Map String String, Integer, Database)
+withDRG' (memory, drg) action =
+  let ((res, n), drg') = withDRG drg action
+  in (res, n, (memory, drg'))
+
+signWith :: HashAlg -> PrivateKey -> BS.ByteString -> Either Error BS.ByteString
+signWith Sha224 = sign Nothing (Just SHA224)
+signWith Sha256 = sign Nothing (Just SHA256)
+signWith Sha384 = sign Nothing (Just SHA384)
+signWith Sha512 = sign Nothing (Just SHA512)
+
+encryptTest :: Int -> Int -> Task
+encryptTest sz cnt = Task {
+    taskName = "RSA " ++ show sz ++ " encryption",
+    taskFile = "../testdata/rsa/encrypt" ++ show sz ++ ".test",
+    taskTest = liftTest go,
+    taskCount = cnt
+  }
+ where
+  go db = withDRG' db go2
+  go2 = do (public, private) <- generate (sz `div` 8) 65537
+           let d = private_d private
+           let n = public_n public
+           msg <- getRandomBytes =<< ((fromIntegral . BS.head) `fmap` getRandomBytes 1)
+           hash <- generateHash
+           label <- do len <- BS.head `fmap` getRandomBytes 1
+                       if odd len
+                         then return Nothing
+                         else Just `fmap` genASCII (len `div` 2)
+           let labelbstr = fromMaybe BS.empty (BSC.pack `fmap` label)
+               labelAlive = if isJust label then 1 else (0 :: Integer)
+           res <- encryptWith hash (BSC.pack `fmap` label) public msg
+           case res of
+             Left _ -> go2
+             Right cipher ->
+               return $ (Map.fromList [("d", showX d),
+                                       ("n", showX n),
+                                       ("k", showX (computeK n)),
+                                       ("u", showX (barrett n)),
+                                       ("h", showHash hash),
+                                       ("m", showBin msg),
+                                       ("l", showBin labelbstr),
+                                       ("e", showX labelAlive),
+                                       ("c", showBin cipher)], n)
+
+genASCII :: MonadRandom m => Word8 -> m String
+genASCII 0 = return ""
+genASCII x =
+  do v <- (BS.head `fmap` getRandomBytes 1)
+     let c = chr (fromIntegral v)
+     if (v < 128) && isPrint c
+       then (c :) `fmap` genASCII (x - 1)
+       else genASCII x
+
+encryptWith :: MonadRandom m =>
+               HashAlg -> Maybe BS.ByteString -> PublicKey -> BS.ByteString ->
+               m (Either Error BS.ByteString)
+encryptWith Sha224 mlabel = encrypt (OAEPParams SHA224 (mgf1 SHA224) mlabel)
+encryptWith Sha256 mlabel = encrypt (OAEPParams SHA256 (mgf1 SHA256) mlabel)
+encryptWith Sha384 mlabel = encrypt (OAEPParams SHA384 (mgf1 SHA384) mlabel)
+encryptWith Sha512 mlabel = encrypt (OAEPParams SHA512 (mgf1 SHA512) mlabel)

test-generator/Task.hs

@@ -1,20 +1,22 @@
+{-# LANGUAGE PackageImports #-}
 module Task(
          Test,
          Task(..),
-         runTask
+         runTask,
+         liftTest
        )
  where
 
-import           Control.Monad(foldM, forM_)
+import              Control.Monad(foldM, forM_)
-import           Crypto.Random(SystemDRG)
+import "crypto-api" Crypto.Random(SystemRandom)
-import qualified Data.Map.Strict as Map
+import qualified    Data.Map.Strict as Map
-import           Database
+import              Database
-import           System.Console.AsciiProgress
+import              System.Console.AsciiProgress
-import           System.Directory(createDirectoryIfMissing,doesFileExist)
+import              System.Directory(createDirectoryIfMissing,doesFileExist)
-import           System.FilePath(takeDirectory)
+import              System.FilePath(takeDirectory)
-import           System.IO(Handle,IOMode(..),hPutStrLn,withFile)
+import              System.IO(Handle,IOMode(..),hPutStrLn,withFile)
 
-type Test = Database -> (Map.Map String String, Integer, Database)
+type Test = Database -> IO (Map.Map String String, Integer, Database)
 
 data Task = Task {
     taskName  :: String,
@@ -23,7 +25,11 @@ data Task = Task {
     taskCount :: Int
 }
 
-runTask :: SystemDRG -> Task -> IO SystemDRG
+liftTest :: (Database -> (Map.Map String String, Integer, Database)) ->
+            (Database -> IO (Map.Map String String, Integer, Database))
+liftTest f db = return (f db)
+
+runTask :: SystemRandom -> Task -> IO SystemRandom
 runTask gen task =
   do createDirectoryIfMissing True (takeDirectory (taskFile task))
      alreadyDone <- doesFileExist (taskFile task)
@@ -39,8 +45,8 @@ runTask gen task =
  where
   writer :: Handle -> ProgressBar -> Test -> Database -> Int -> IO Database
   writer hndl pg runner db x =
-    do let (output, key, acc@(db',gen')) = runner db
+    do (output, key, acc@(db',gen')) <- runner db
-           before = Map.findWithDefault [] "RESULT" db'
+       let before = Map.findWithDefault [] "RESULT" db'
        if length (filter (== key) before) >= 10
           then writer hndl pg runner acc x
           else do forM_ (Map.toList output) $ \ (outkey, val) ->

test-generator/Utils.hs

@@ -1,9 +1,10 @@
+{-# LANGUAGE PackageImports #-}
 module Utils(HashAlg(..), generateHash, runHash, showHash)
  where
 
 import Crypto.Hash(Digest,SHA224(..),SHA256(..),SHA384(..),SHA512(..),hash)
 import Crypto.Number.Generate(generateBetween)
-import Crypto.Random(MonadRandom)
+import "cryptonite" Crypto.Random(MonadRandom)
 import qualified Data.ByteArray as B
 import qualified Data.ByteString as S
 import Math(showX)

test-generator/cbits/GFp/aes.h

@@ -0,0 +1,96 @@
+/* ====================================================================
+ * Copyright (c) 2002-2006 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ==================================================================== */
+
+#ifndef OPENSSL_HEADER_AES_H
+#define OPENSSL_HEADER_AES_H
+
+#include <GFp/base.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/* Raw AES functions. */
+
+
+#define AES_ENCRYPT 1
+#define AES_DECRYPT 0
+
+/* AES_MAXNR is the maximum number of AES rounds. */
+#define AES_MAXNR 14
+
+#define AES_BLOCK_SIZE 16
+
+/* aes_key_st should be an opaque type, but EVP requires that the size be
+ * known. */
+struct aes_key_st {
+  uint32_t rd_key[4 * (AES_MAXNR + 1)];
+  unsigned rounds;
+};
+typedef struct aes_key_st AES_KEY;
+
+/* GFp_AES_set_encrypt_key configures |aeskey| to encrypt with the |bits|-bit
+ * key, |key|.
+ *
+ * WARNING: unlike other OpenSSL functions, this returns zero on success and a
+ * negative number on error. */
+OPENSSL_EXPORT int GFp_AES_set_encrypt_key(const uint8_t *key, unsigned bits,
+                                           AES_KEY *aeskey);
+
+/* AES_encrypt encrypts a single block from |in| to |out| with |key|. The |in|
+ * and |out| pointers may overlap. */
+OPENSSL_EXPORT void GFp_AES_encrypt(const uint8_t *in, uint8_t *out,
+                                    const AES_KEY *key);
+
+
+#if defined(__cplusplus)
+}  /* extern C */
+#endif
+
+#endif  /* OPENSSL_HEADER_AES_H */

test-generator/cbits/GFp/arm_arch.h

@@ -0,0 +1,123 @@
+/* ====================================================================
+ * Copyright (c) 1998-2011 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com). */
+
+#ifndef OPENSSL_HEADER_ARM_ARCH_H
+#define OPENSSL_HEADER_ARM_ARCH_H
+
+#if !defined(__ARM_ARCH__)
+# if defined(__CC_ARM)
+#  define __ARM_ARCH__ __TARGET_ARCH_ARM
+#  if defined(__BIG_ENDIAN)
+#   define __ARMEB__
+#  else
+#   define __ARMEL__
+#  endif
+# elif defined(__GNUC__)
+#  if defined(__aarch64__)
+#    define __ARM_ARCH__ 8
+#    if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#      define __ARMEB__
+#    else
+#      define __ARMEL__
+#    endif
+  /* Why doesn't gcc define __ARM_ARCH__? Instead it defines
+   * bunch of below macros. See all_architectires[] table in
+   * gcc/config/arm/arm.c. On a side note it defines
+   * __ARMEL__/__ARMEB__ for little-/big-endian. */
+#  elif	defined(__ARM_ARCH)
+#    define __ARM_ARCH__ __ARM_ARCH
+#  elif	defined(__ARM_ARCH_8A__)
+#    define __ARM_ARCH__ 8
+#  elif	defined(__ARM_ARCH_7__)	|| defined(__ARM_ARCH_7A__)	|| \
+	defined(__ARM_ARCH_7R__)|| defined(__ARM_ARCH_7M__)	|| \
+	defined(__ARM_ARCH_7EM__)
+#   define __ARM_ARCH__ 7
+#  elif	defined(__ARM_ARCH_6__)	|| defined(__ARM_ARCH_6J__)	|| \
+	defined(__ARM_ARCH_6K__)|| defined(__ARM_ARCH_6M__)	|| \
+	defined(__ARM_ARCH_6Z__)|| defined(__ARM_ARCH_6ZK__)	|| \
+	defined(__ARM_ARCH_6T2__)
+#   define __ARM_ARCH__ 6
+#  elif	defined(__ARM_ARCH_5__)	|| defined(__ARM_ARCH_5T__)	|| \
+	defined(__ARM_ARCH_5E__)|| defined(__ARM_ARCH_5TE__)	|| \
+	defined(__ARM_ARCH_5TEJ__)
+#   define __ARM_ARCH__ 5
+#  elif	defined(__ARM_ARCH_4__)	|| defined(__ARM_ARCH_4T__)
+#   define __ARM_ARCH__ 4
+#  else
+#   error "unsupported ARM architecture"
+#  endif
+# endif
+#endif
+
+/* Even when building for 32-bit ARM, support for aarch64 crypto instructions
+ * will be included. */
+#if !defined(__ARM_MAX_ARCH__)
+#define __ARM_MAX_ARCH__ 8
+#endif
+
+/* ARMV7_NEON is true when a NEON unit is present in the current CPU. */
+#define ARMV7_NEON (1 << 0)
+
+/* ARMV8_AES indicates support for hardware AES instructions. */
+#define ARMV8_AES (1 << 2)
+
+/* ARMV8_SHA1 indicates support for hardware SHA-1 instructions. */
+#define ARMV8_SHA1 (1 << 3)
+
+/* ARMV8_SHA256 indicates support for hardware SHA-256 instructions. */
+#define ARMV8_SHA256 (1 << 4)
+
+/* ARMV8_PMULL indicates support for carryless multiplication. */
+#define ARMV8_PMULL (1 << 5)
+
+
+#endif  /* OPENSSL_HEADER_ARM_ARCH_H */

test-generator/cbits/GFp/base.h

@@ -0,0 +1,122 @@
+/* ====================================================================
+ * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com). */
+
+#ifndef OPENSSL_HEADER_BASE_H
+#define OPENSSL_HEADER_BASE_H
+
+
+/* This file should be the first included by all BoringSSL headers. */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/types.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#if defined(__x86_64) || defined(_M_AMD64) || defined(_M_X64)
+#define OPENSSL_64_BIT
+#define OPENSSL_X86_64
+#elif defined(__x86) || defined(__i386) || defined(__i386__) || defined(_M_IX86)
+#define OPENSSL_32_BIT
+#define OPENSSL_X86
+#elif defined(__aarch64__)
+#define OPENSSL_64_BIT
+#define OPENSSL_AARCH64
+#elif defined(__arm) || defined(__arm__) || defined(_M_ARM)
+#define OPENSSL_32_BIT
+#define OPENSSL_ARM
+#elif (defined(__PPC64__) || defined(__powerpc64__)) && defined(_LITTLE_ENDIAN)
+#define OPENSSL_64_BIT
+#define OPENSSL_PPC64LE
+#elif defined(__mips__) && !defined(__LP64__)
+#define OPENSSL_32_BIT
+#define OPENSSL_MIPS
+#elif defined(__mips__) && defined(__LP64__)
+#define OPENSSL_64_BIT
+#define OPENSSL_MIPS64
+#elif defined(__pnacl__)
+#define OPENSSL_32_BIT
+#define OPENSSL_PNACL
+#elif defined(__myriad2__)
+#define OPENSSL_32_BIT
+#else
+#error "Unknown target CPU"
+#endif
+
+#if defined(__APPLE__)
+#define OPENSSL_APPLE
+#endif
+
+#if defined(_WIN32)
+#define OPENSSL_WINDOWS
+#endif
+
+#define OPENSSL_IS_BORINGSSL
+#define OPENSSL_IS_RING
+#define OPENSSL_VERSION_NUMBER 0x10002000
+
+/* *ring* doesn't support the `BORINGSSL_SHARED_LIBRARY` configuration, so
+ * the default (usually "hidden") visibility is always used, even for exported
+ * items. */
+#define OPENSSL_EXPORT
+
+typedef struct bignum_st BIGNUM;
+
+
+#if defined(__cplusplus)
+}  /* extern C */
+#endif
+
+#endif  /* OPENSSL_HEADER_BASE_H */

test-generator/cbits/GFp/bn.h

@@ -0,0 +1,256 @@
+/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+/* ====================================================================
+ * Copyright (c) 1998-2006 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+/* ====================================================================
+ * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
+ *
+ * Portions of the attached software ("Contribution") are developed by
+ * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
+ *
+ * The Contribution is licensed pursuant to the Eric Young open source
+ * license provided above.
+ *
+ * The binary polynomial arithmetic software is originally written by
+ * Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems
+ * Laboratories. */
+
+#ifndef OPENSSL_HEADER_BN_H
+#define OPENSSL_HEADER_BN_H
+
+#include <GFp/base.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/* BN provides support for working with arbitrary sized integers. For example,
+ * although the largest integer supported by the compiler might be 64 bits, BN
+ * will allow you to work with numbers until you run out of memory. */
+
+
+/* BN_ULONG is the native word size when working with big integers.
+ *
+ * Note: on some platforms, inttypes.h does not define print format macros in
+ * C++ unless |__STDC_FORMAT_MACROS| defined. As this is a public header, bn.h
+ * does not define |__STDC_FORMAT_MACROS| itself. C++ source files which use the
+ * FMT macros must define it externally. */
+#if defined(OPENSSL_64_BIT)
+#define BN_ULONG uint64_t
+#define BN_BITS2 64
+#elif defined(OPENSSL_32_BIT)
+#define BN_ULONG uint32_t
+#define BN_BITS2 32
+#else
+#error "Must define either OPENSSL_32_BIT or OPENSSL_64_BIT"
+#endif
+
+
+/* Allocation and freeing. */
+
+/* GFp_BN_init initialises a stack allocated |BIGNUM|. */
+OPENSSL_EXPORT void GFp_BN_init(BIGNUM *bn);
+
+/* GFp_BN_free frees the data referenced by |bn| and, if |bn| was originally
+ * allocated on the heap, frees |bn| also. */
+OPENSSL_EXPORT void GFp_BN_free(BIGNUM *bn);
+
+/* GFp_BN_copy sets |dest| equal to |src| and returns one on success or zero on
+ * failure. */
+OPENSSL_EXPORT int GFp_BN_copy(BIGNUM *dest, const BIGNUM *src);
+
+
+/* Basic functions. */
+
+/* GFp_BN_zero sets |bn| to zero. */
+OPENSSL_EXPORT void GFp_BN_zero(BIGNUM *bn);
+
+
+/* Internal functions.
+ *
+ * These functions are useful for code that is doing low-level manipulations of
+ * BIGNUM values. However, be sure that no other function in this file does
+ * what you want before turning to these. */
+
+/* bn_correct_top decrements |bn->top| until |bn->d[top-1]| is non-zero or
+ * until |top| is zero. */
+OPENSSL_EXPORT void GFp_bn_correct_top(BIGNUM *bn);
+
+/* bn_wexpand ensures that |bn| has at least |words| works of space without
+ * altering its value. It returns one on success and zero on allocation
+ * failure. */
+OPENSSL_EXPORT int GFp_bn_wexpand(BIGNUM *bn, size_t words);
+
+
+/* Simple arithmetic */
+
+/* GFp_BN_mul_no_alias sets |r| = |a| * |b|, where |r| must not be the same pointer
+ * as |a| or |b|. Returns one on success and zero otherwise. */
+OPENSSL_EXPORT int GFp_BN_mul_no_alias(BIGNUM *r, const BIGNUM *a, const BIGNUM *b);
+
+
+/* Comparison functions */
+
+/* GFp_BN_is_odd returns one if |bn| is odd and zero otherwise. */
+OPENSSL_EXPORT int GFp_BN_is_odd(const BIGNUM *bn);
+
+
+/* Bitwise operations. */
+
+/* GFp_BN_is_bit_set returns the value of the |n|th, least-significant bit in
+ * |a|, or zero if the bit doesn't exist. */
+OPENSSL_EXPORT int GFp_BN_is_bit_set(const BIGNUM *a, int n);
+
+
+/* Modulo arithmetic. */
+
+/* GFp_BN_mod_mul_mont set |r| equal to |a| * |b|, in the Montgomery domain.
+ * Both |a| and |b| must already be in the Montgomery domain (by
+ * |GFp_BN_to_mont|). In particular, |a| and |b| are assumed to be in the range
+ * [0, n), where |n| is the Montgomery modulus. It returns one on success or
+ * zero on error. */
+OPENSSL_EXPORT int GFp_BN_mod_mul_mont(
+    BIGNUM *r, const BIGNUM *a, const BIGNUM *b, const BIGNUM *n,
+    const BN_ULONG n0[/*BN_MONT_CTX_N0_LIMBS*/]);
+
+/* GFp_BN_reduce_montgomery returns |a % n| in constant-ish time using
+ * Montgomery reduction. |a| is assumed to be in the range [0, n**2), where |n|
+ * is the Montgomery modulus. It returns one on success or zero on error. */
+int GFp_BN_reduce_mont(BIGNUM *r, const BIGNUM *a, const BIGNUM *n,
+                       const BN_ULONG n0[/*BN_MONT_CTX_N0_LIMBS*/]);
+
+
+/* Exponentiation. */
+
+OPENSSL_EXPORT int GFp_BN_mod_exp_mont_consttime(
+    BIGNUM *rr, const BIGNUM *a_mont, const BIGNUM *p, size_t p_bits,
+    const BIGNUM *one_mont, const BIGNUM *n,
+    const BN_ULONG n0[/*BN_MONT_CTX_N0_LIMBS*/]);
+
+
+/* Private functions */
+
+/* Keep in sync with `BIGNUM` in `ring::rsa::bigint`. */
+struct bignum_st {
+  BN_ULONG *d; /* Pointer to an array of 'BN_BITS2' bit chunks in little-endian
+                  order. */
+  int top;   /* Index of last used element in |d|, plus one. */
+  int dmax;  /* Size of |d|, in words. */
+  int flags; /* bitmask of BN_FLG_* values */
+};
+
+#define BN_FLG_MALLOCED 0x01
+#define BN_FLG_STATIC_DATA 0x02
+
+
+#if defined(__cplusplus)
+}  /* extern C */
+#endif
+
+#endif  /* OPENSSL_HEADER_BN_H */

test-generator/cbits/GFp/cpu.h

@@ -0,0 +1,189 @@
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com). */
+
+#ifndef OPENSSL_HEADER_CPU_H
+#define OPENSSL_HEADER_CPU_H
+
+#include <GFp/base.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/* Runtime CPU feature support */
+
+
+#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64)
+/* GFp_ia32cap_P contains the Intel CPUID bits when running on an x86 or
+ * x86-64 system.
+ *
+ *   Index 0:
+ *     EDX for CPUID where EAX = 1
+ *     Bit 20 is always zero
+ *     Bit 28 is adjusted to reflect whether the data cache is shared between
+ *       multiple logical cores
+ *     Bit 30 is used to indicate an Intel CPU
+ *   Index 1:
+ *     ECX for CPUID where EAX = 1
+ *     Bit 11 is used to indicate AMD XOP support, not SDBG
+ *   Index 2:
+ *     EBX for CPUID where EAX = 7
+ *   Index 3 is set to zero.
+ *
+ * Note: the CPUID bits are pre-adjusted for the OSXSAVE bit and the YMM and XMM
+ * bits in XCR0, so it is not necessary to check those. */
+extern uint32_t GFp_ia32cap_P[4];
+#endif
+
+#if defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64)
+
+#if defined(OPENSSL_APPLE)
+/* iOS builds use the static ARM configuration. */
+#define OPENSSL_STATIC_ARMCAP
+
+#if defined(OPENSSL_AARCH64)
+#define OPENSSL_STATIC_ARMCAP_AES
+#define OPENSSL_STATIC_ARMCAP_SHA1
+#define OPENSSL_STATIC_ARMCAP_SHA256
+#define OPENSSL_STATIC_ARMCAP_PMULL
+#endif
+
+#endif
+
+#if !defined(OPENSSL_STATIC_ARMCAP)
+
+/* GFp_is_NEON_capable_at_runtime returns true if the current CPU has a NEON
+ * unit. Note that |OPENSSL_armcap_P| also exists and contains the same
+ * information in a form that's easier for assembly to use. */
+OPENSSL_EXPORT uint8_t GFp_is_NEON_capable_at_runtime(void);
+
+/* GFp_is_NEON_capable returns true if the current CPU has a NEON unit. If
+ * this is known statically then it returns one immediately. */
+static inline int GFp_is_NEON_capable(void) {
+  /* On 32-bit ARM, one CPU is known to have a broken NEON unit which is known
+   * to fail with on some hand-written NEON assembly. Assume that non-Android
+   * applications will not use that buggy CPU but still support Android users
+   * that do, even when the compiler is instructed to freely emit NEON code.
+   * See https://crbug.com/341598 and https://crbug.com/606629. */
+#if defined(__ARM_NEON__) && (!defined(OPENSSL_ARM) || !defined(__ANDROID__))
+  return 1;
+#else
+  return GFp_is_NEON_capable_at_runtime();
+#endif
+}
+
+#if defined(OPENSSL_ARM)
+/* GFp_has_broken_NEON returns one if the current CPU is known to have a
+ * broken NEON unit. See https://crbug.com/341598. */
+OPENSSL_EXPORT int GFp_has_broken_NEON(void);
+#endif
+
+/* GFp_is_ARMv8_AES_capable returns true if the current CPU supports the
+ * ARMv8 AES instruction. */
+int GFp_is_ARMv8_AES_capable(void);
+
+/* GFp_is_ARMv8_PMULL_capable returns true if the current CPU supports the
+ * ARMv8 PMULL instruction. */
+int GFp_is_ARMv8_PMULL_capable(void);
+
+#else
+
+static inline int GFp_is_NEON_capable(void) {
+#if defined(OPENSSL_STATIC_ARMCAP_NEON) || defined(__ARM_NEON__)
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+static inline int GFp_is_ARMv8_AES_capable(void) {
+#if defined(OPENSSL_STATIC_ARMCAP_AES)
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+static inline int GFp_is_ARMv8_PMULL_capable(void) {
+#if defined(OPENSSL_STATIC_ARMCAP_PMULL)
+  return 1;
+#else
+  return 0;
+#endif
+}
+
+#endif  /* OPENSSL_STATIC_ARMCAP */
+#endif  /* OPENSSL_ARM || OPENSSL_AARCH64 */
+
+#if defined(OPENSSL_PPC64LE)
+
+/* CRYPTO_is_PPC64LE_vcrypto_capable returns true iff the current CPU supports
+ * the Vector.AES category of instructions. */
+int CRYPTO_is_PPC64LE_vcrypto_capable(void);
+
+#endif  /* OPENSSL_PPC64LE */
+
+
+#if defined(__cplusplus)
+}  /* extern C */
+#endif
+
+#endif  /* OPENSSL_HEADER_CPU_H */

test-generator/cbits/GFp/mem.h

@@ -0,0 +1,93 @@
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.] */
+
+#ifndef OPENSSL_HEADER_MEM_H
+#define OPENSSL_HEADER_MEM_H
+
+#include <GFp/base.h>
+
+#include <stdlib.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/* Memory and string functions, see also buf.h.
+ *
+ * OpenSSL has, historically, had a complex set of malloc debugging options.
+ * However, that was written in a time before Valgrind and ASAN. Since we now
+ * have those tools, the OpenSSL allocation functions are simply macros around
+ * the standard memory functions. */
+
+
+#define OPENSSL_malloc malloc
+#define OPENSSL_realloc realloc
+#define OPENSSL_free free
+
+/* GFp_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. It
+ * takes an amount of time dependent on |len|, but independent of the contents
+ * of |a| and |b|. Unlike memcmp, it cannot be used to put elements into a
+ * defined order as the return value when a != b is undefined, other than to be
+ * non-zero. */
+OPENSSL_EXPORT int GFp_memcmp(const void *a, const void *b, size_t len);
+
+
+#if defined(__cplusplus)
+}  /* extern C */
+#endif
+
+#endif  /* OPENSSL_HEADER_MEM_H */

test-generator/cbits/GFp/type_check.h

@@ -0,0 +1,75 @@
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.] */
+
+#ifndef OPENSSL_HEADER_TYPE_CHECK_H
+#define OPENSSL_HEADER_TYPE_CHECK_H
+
+#include <GFp/base.h>
+
+
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#define OPENSSL_COMPILE_ASSERT(cond, msg) _Static_assert(cond, #msg)
+#elif defined(__GNUC__)
+#define OPENSSL_COMPILE_ASSERT(cond, msg)                      \
+  typedef char OPENSSL_COMPILE_ASSERT_##msg[((cond) ? 1 : -1)] \
+      __attribute__((unused))
+#else
+#define OPENSSL_COMPILE_ASSERT(cond, msg) \
+  typedef char OPENSSL_COMPILE_ASSERT_##msg[((cond) ? 1 : -1)]
+#endif
+
+
+#endif  /* OPENSSL_HEADER_TYPE_CHECK_H */

test-generator/cbits/internal.h

@@ -0,0 +1,109 @@
+/* Copyright (c) 2015, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+#ifndef OPENSSL_HEADER_CURVE25519_INTERNAL_H
+#define OPENSSL_HEADER_CURVE25519_INTERNAL_H
+
+#include <GFp/base.h>
+
+#include <stdint.h>
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#if defined(OPENSSL_X86_64) && !defined(OPENSSL_SMALL) && \
+    !defined(OPENSSL_WINDOWS) && !defined(OPENSSL_NO_ASM)
+/* This isn't compatible with Windows because the asm code makes use of the red
+ * zone, which Windows doesn't support. */
+#define BORINGSSL_X25519_X86_64
+
+void GFp_x25519_x86_64(uint8_t out[32], const uint8_t scalar[32],
+                       const uint8_t point[32]);
+#endif
+
+
+#if defined(OPENSSL_ARM) && !defined(OPENSSL_NO_ASM)
+#define BORINGSSL_X25519_NEON
+
+/* x25519_NEON is defined in asm/x25519-arm.S. */
+void GFp_x25519_NEON(uint8_t out[32], const uint8_t scalar[32],
+                     const uint8_t point[32]);
+#endif
+
+/* fe means field element. Here the field is \Z/(2^255-19). An element t,
+ * entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77
+ * t[3]+2^102 t[4]+...+2^230 t[9]. Bounds on each t[i] vary depending on
+ * context.
+ *
+ * Keep in sync with `Elem` and `ELEM_LIMBS` in curve25519/ops.rs. */
+typedef int32_t fe[10];
+
+/* ge means group element.
+
+ * Here the group is the set of pairs (x,y) of field elements (see fe.h)
+ * satisfying -x^2 + y^2 = 1 + d x^2y^2
+ * where d = -121665/121666.
+ *
+ * Representations:
+ *   ge_p2 (projective): (X:Y:Z) satisfying x=X/Z, y=Y/Z
+ *   ge_p3 (extended): (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+ *   ge_p1p1 (completed): ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+ *   ge_precomp (Duif): (y+x,y-x,2dxy)
+ */
+
+/* Keep in sync with `Point` in curve25519/ops.rs. */
+typedef struct {
+  fe X;
+  fe Y;
+  fe Z;
+} ge_p2;
+
+
+/* Keep in sync with `ExtPoint` in curve25519/ops.rs. */
+typedef struct {
+  fe X;
+  fe Y;
+  fe Z;
+  fe T;
+} ge_p3;
+
+typedef struct {
+  fe X;
+  fe Y;
+  fe Z;
+  fe T;
+} ge_p1p1;
+
+typedef struct {
+  fe yplusx;
+  fe yminusx;
+  fe xy2d;
+} ge_precomp;
+
+typedef struct {
+  fe YplusX;
+  fe YminusX;
+  fe Z;
+  fe T2d;
+} ge_cached;
+
+
+#if defined(__cplusplus)
+}  /* extern C */
+#endif
+
+#endif  /* OPENSSL_HEADER_CURVE25519_INTERNAL_H */

test-generator/cbits/internal2.h

@@ -0,0 +1,361 @@
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+/* ====================================================================
+ * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@openssl.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com). */
+
+#ifndef OPENSSL_HEADER_CRYPTO_INTERNAL_H
+#define OPENSSL_HEADER_CRYPTO_INTERNAL_H
+
+#include <assert.h>
+
+#if defined(__clang__) || defined(_MSC_VER)
+#include <string.h>
+#endif
+
+#include <stddef.h>
+
+#include <GFp/base.h>
+#include <GFp/type_check.h>
+
+#if defined(_MSC_VER)
+#pragma warning(push, 3)
+#include <intrin.h>
+#pragma warning(pop)
+#if !defined(__cplusplus)
+#define alignas(x) __declspec(align(x))
+#define alignof __alignof
+#endif
+#elif !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 4 && \
+      __GNUC_MINOR__ <= 6
+#define alignas(x) __attribute__((aligned (x)))
+#define alignof __alignof__
+#else
+#include <stdalign.h>
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64) || defined(OPENSSL_ARM) || \
+    defined(OPENSSL_AARCH64) || defined(OPENSSL_PPC64LE)
+/* OPENSSL_cpuid_setup initializes the platform-specific feature cache. */
+void GFp_cpuid_setup(void);
+#endif
+
+#define OPENSSL_LITTLE_ENDIAN 1
+#define OPENSSL_BIG_ENDIAN 2
+
+#if defined(OPENSSL_X86_64) || defined(OPENSSL_X86) || \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define OPENSSL_ENDIAN OPENSSL_LITTLE_ENDIAN
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+      __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define OPENSSL_ENDIAN OPENSSL_BIG_ENDIAN
+#else
+#error "Cannot determine endianness"
+#endif
+
+
+#if defined(__GNUC__)
+#define bswap_u32(x) __builtin_bswap32(x)
+#define bswap_u64(x) __builtin_bswap64(x)
+#elif defined(_MSC_VER)
+#pragma intrinsic(_byteswap_ulong, _byteswap_uint64)
+#define bswap_u32(x) _byteswap_ulong(x)
+#define bswap_u64(x) _byteswap_uint64(x)
+#endif
+
+
+#if !defined(_MSC_VER) && defined(OPENSSL_64_BIT)
+typedef __int128_t int128_t;
+typedef __uint128_t uint128_t;
+#endif
+
+
+/* Constant-time utility functions.
+ *
+ * The following methods return a bitmask of all ones (0xff...f) for true and 0
+ * for false. This is useful for choosing a value based on the result of a
+ * conditional in constant time. */
+
+/* constant_time_msb returns the given value with the MSB copied to all the
+ * other bits. */
+static inline unsigned int constant_time_msb_unsigned(unsigned int a) {
+  return (unsigned int)((int)(a) >> (sizeof(int) * 8 - 1));
+}
+
+OPENSSL_COMPILE_ASSERT(sizeof(ptrdiff_t) == sizeof(size_t),
+                       ptrdiff_t_and_size_t_are_different_sizes);
+
+static inline size_t constant_time_msb_size_t(size_t a) {
+  return (size_t)((ptrdiff_t)(a) >> (sizeof(ptrdiff_t) * 8 - 1));
+}
+
+
+/* constant_time_is_zero returns 0xff..f if a == 0 and 0 otherwise. */
+static inline unsigned int constant_time_is_zero_unsigned(unsigned int a) {
+  /* Here is an SMT-LIB verification of this formula:
+   *
+   * (define-fun is_zero ((a (_ BitVec 32))) (_ BitVec 32)
+   *   (bvand (bvnot a) (bvsub a #x00000001))
+   * )
+   *
+   * (declare-fun a () (_ BitVec 32))
+   *
+   * (assert (not (= (= #x00000001 (bvlshr (is_zero a) #x0000001f)) (= a #x00000000))))
+   * (check-sat)
+   * (get-model)
+   */
+  return constant_time_msb_unsigned(~a & (a - 1));
+}
+
+/* constant_time_is_zero_size_t is like |constant_time_is_zero_unsigned| but
+ * operates on |size_t|. */
+static inline size_t constant_time_is_zero_size_t(size_t a) {
+  return constant_time_msb_size_t(~a & (a - 1));
+}
+
+static inline size_t constant_time_is_nonzero_size_t(size_t a) {
+  return constant_time_is_zero_size_t(constant_time_is_zero_size_t(a));
+}
+
+/* constant_time_eq_int returns 0xff..f if a == b and 0 otherwise. */
+static inline unsigned int constant_time_eq_int(int a, int b) {
+  return constant_time_is_zero_unsigned((unsigned)(a) ^ (unsigned)(b));
+}
+
+/* constant_time_eq_size_t acts like |constant_time_eq_int| but operates on
+ * |size_t|. */
+static inline size_t constant_time_eq_size_t(size_t a, size_t b) {
+  return constant_time_is_zero_size_t(a ^ b);
+}
+
+/* constant_time_select_size_t returns (mask & a) | (~mask & b). When |mask| is
+ * all 1s or all 0s (as returned by the methods above), the select methods
+ * return either |a| (if |mask| is nonzero) or |b| (if |mask| is zero). it is
+ * derived from BoringSSL's |constant_time_select|. */
+static inline size_t constant_time_select_size_t(size_t mask, size_t a,
+                                                 size_t b) {
+  return (mask & a) | (~mask & b);
+}
+
+/* from_be_u32_ptr returns the 32-bit big-endian-encoded value at |data|. */
+static inline uint32_t from_be_u32_ptr(const uint8_t *data) {
+#if defined(__clang__) || defined(_MSC_VER)
+  /* XXX: Unlike GCC, Clang doesn't optimize compliant access to unaligned data
+   * well. See https://llvm.org/bugs/show_bug.cgi?id=20605,
+   * https://llvm.org/bugs/show_bug.cgi?id=17603,
+   * http://blog.regehr.org/archives/702, and
+   * http://blog.regehr.org/archives/1055. MSVC seems to have similar problems.
+   */
+  uint32_t value;
+  memcpy(&value, data, sizeof(value));
+#if OPENSSL_ENDIAN != OPENSSL_BIG_ENDIAN
+  value = bswap_u32(value);
+#endif
+  return value;
+#else
+  return ((uint32_t)data[0] << 24) |
+         ((uint32_t)data[1] << 16) |
+         ((uint32_t)data[2] << 8) |
+         ((uint32_t)data[3]);
+#endif
+}
+
+
+/* from_be_u64_ptr returns the 64-bit big-endian-encoded value at |data|. */
+static inline uint64_t from_be_u64_ptr(const uint8_t *data) {
+#if defined(__clang__) || defined(_MSC_VER)
+  /* XXX: Unlike GCC, Clang doesn't optimize compliant access to unaligned data
+   * well. See https://llvm.org/bugs/show_bug.cgi?id=20605,
+   * https://llvm.org/bugs/show_bug.cgi?id=17603,
+   * http://blog.regehr.org/archives/702, and
+   * http://blog.regehr.org/archives/1055. MSVC seems to have similar problems.
+   */
+  uint64_t value;
+  memcpy(&value, data, sizeof(value));
+#if OPENSSL_ENDIAN != OPENSSL_BIG_ENDIAN
+  value = bswap_u64(value);
+#endif
+  return value;
+#else
+  return ((uint64_t)data[0] << 56) |
+         ((uint64_t)data[1] << 48) |
+         ((uint64_t)data[2] << 40) |
+         ((uint64_t)data[3] << 32) |
+         ((uint64_t)data[4] << 24) |
+         ((uint64_t)data[5] << 16) |
+         ((uint64_t)data[6] << 8) |
+         ((uint64_t)data[7]);
+#endif
+}
+
+/* to_be_u32_ptr writes the value |x| to the location |out| in big-endian
+   order. */
+static inline void to_be_u32_ptr(uint8_t *out, uint32_t value) {
+#if defined(__clang__) || defined(_MSC_VER)
+  /* XXX: Unlike GCC, Clang doesn't optimize compliant access to unaligned data
+   * well. See https://llvm.org/bugs/show_bug.cgi?id=20605,
+   * https://llvm.org/bugs/show_bug.cgi?id=17603,
+   * http://blog.regehr.org/archives/702, and
+   * http://blog.regehr.org/archives/1055. MSVC seems to have similar problems.
+   */
+#if  OPENSSL_ENDIAN != OPENSSL_BIG_ENDIAN
+  value = bswap_u32(value);
+#endif
+  memcpy(out, &value, sizeof(value));
+#else
+  out[0] = (uint8_t)(value >> 24);
+  out[1] = (uint8_t)(value >> 16);
+  out[2] = (uint8_t)(value >> 8);
+  out[3] = (uint8_t)value;
+#endif
+}
+
+/* to_be_u64_ptr writes the value |value| to the location |out| in big-endian
+   order. */
+static inline void to_be_u64_ptr(uint8_t *out, uint64_t value) {
+#if defined(__clang__) || defined(_MSC_VER)
+  /* XXX: Unlike GCC, Clang doesn't optimize compliant access to unaligned data
+   * well. See https://llvm.org/bugs/show_bug.cgi?id=20605,
+   * https://llvm.org/bugs/show_bug.cgi?id=17603,
+   * http://blog.regehr.org/archives/702, and
+   * http://blog.regehr.org/archives/1055. MSVC seems to have similar problems.
+   */
+#if  OPENSSL_ENDIAN != OPENSSL_BIG_ENDIAN
+  value = bswap_u64(value);
+#endif
+  memcpy(out, &value, sizeof(value));
+#else
+  out[0] = (uint8_t)(value >> 56);
+  out[1] = (uint8_t)(value >> 48);
+  out[2] = (uint8_t)(value >> 40);
+  out[3] = (uint8_t)(value >> 32);
+  out[4] = (uint8_t)(value >> 24);
+  out[5] = (uint8_t)(value >> 16);
+  out[6] = (uint8_t)(value >> 8);
+  out[7] = (uint8_t)value;
+#endif
+}
+
+/* from_be_u64 returns the native representation of the 64-bit
+ * big-endian-encoded value |x|. */
+static inline uint64_t from_be_u64(uint64_t x) {
+#if OPENSSL_ENDIAN != OPENSSL_BIG_ENDIAN
+  x = bswap_u64(x);
+#endif
+  return x;
+}
+
+
+#if defined(__cplusplus)
+}  /* extern C */
+#endif
+
+#endif  /* OPENSSL_HEADER_CRYPTO_INTERNAL_H */

test-generator/cbits/x25519-x86_64.c

@@ -0,0 +1,244 @@
+/* Copyright (c) 2015, Google Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
+
+/* This code is mostly taken from the ref10 version of Ed25519 in SUPERCOP
+ * 20141124 (http://bench.cr.yp.to/supercop.html). That code is released as
+ * public domain but this file has the ISC license just to keep licencing
+ * simple.
+ *
+ * The field functions are shared by Ed25519 and X25519 where possible. */
+
+#include <string.h>
+
+#include "internal.h"
+
+
+#if defined(BORINGSSL_X25519_X86_64)
+
+typedef struct { uint64_t v[5]; } fe25519;
+
+/* These functions are defined in asm/x25519-x86_64.S */
+void GFp_x25519_x86_64_work_cswap(fe25519 *, uint64_t);
+void GFp_x25519_x86_64_mul(fe25519 *out, const fe25519 *a, const fe25519 *b);
+void GFp_x25519_x86_64_square(fe25519 *out, const fe25519 *a);
+void GFp_x25519_x86_64_freeze(fe25519 *);
+void GFp_x25519_x86_64_ladderstep(fe25519 *work);
+
+static void fe25519_setint(fe25519 *r, unsigned v) {
+  r->v[0] = v;
+  r->v[1] = 0;
+  r->v[2] = 0;
+  r->v[3] = 0;
+  r->v[4] = 0;
+}
+
+/* Assumes input x being reduced below 2^255 */
+static void fe25519_pack(unsigned char r[32], const fe25519 *x) {
+  fe25519 t;
+  t = *x;
+  GFp_x25519_x86_64_freeze(&t);
+
+  r[0] = (uint8_t)(t.v[0] & 0xff);
+  r[1] = (uint8_t)((t.v[0] >> 8) & 0xff);
+  r[2] = (uint8_t)((t.v[0] >> 16) & 0xff);
+  r[3] = (uint8_t)((t.v[0] >> 24) & 0xff);
+  r[4] = (uint8_t)((t.v[0] >> 32) & 0xff);
+  r[5] = (uint8_t)((t.v[0] >> 40) & 0xff);
+  r[6] = (uint8_t)((t.v[0] >> 48));
+
+  r[6] ^= (uint8_t)((t.v[1] << 3) & 0xf8);
+  r[7] = (uint8_t)((t.v[1] >> 5) & 0xff);
+  r[8] = (uint8_t)((t.v[1] >> 13) & 0xff);
+  r[9] = (uint8_t)((t.v[1] >> 21) & 0xff);
+  r[10] = (uint8_t)((t.v[1] >> 29) & 0xff);
+  r[11] = (uint8_t)((t.v[1] >> 37) & 0xff);
+  r[12] = (uint8_t)((t.v[1] >> 45));
+
+  r[12] ^= (uint8_t)((t.v[2] << 6) & 0xc0);
+  r[13] = (uint8_t)((t.v[2] >> 2) & 0xff);
+  r[14] = (uint8_t)((t.v[2] >> 10) & 0xff);
+  r[15] = (uint8_t)((t.v[2] >> 18) & 0xff);
+  r[16] = (uint8_t)((t.v[2] >> 26) & 0xff);
+  r[17] = (uint8_t)((t.v[2] >> 34) & 0xff);
+  r[18] = (uint8_t)((t.v[2] >> 42) & 0xff);
+  r[19] = (uint8_t)((t.v[2] >> 50));
+
+  r[19] ^= (uint8_t)((t.v[3] << 1) & 0xfe);
+  r[20] = (uint8_t)((t.v[3] >> 7) & 0xff);
+  r[21] = (uint8_t)((t.v[3] >> 15) & 0xff);
+  r[22] = (uint8_t)((t.v[3] >> 23) & 0xff);
+  r[23] = (uint8_t)((t.v[3] >> 31) & 0xff);
+  r[24] = (uint8_t)((t.v[3] >> 39) & 0xff);
+  r[25] = (uint8_t)((t.v[3] >> 47));
+
+  r[25] ^= (uint8_t)((t.v[4] << 4) & 0xf0);
+  r[26] = (uint8_t)((t.v[4] >> 4) & 0xff);
+  r[27] = (uint8_t)((t.v[4] >> 12) & 0xff);
+  r[28] = (uint8_t)((t.v[4] >> 20) & 0xff);
+  r[29] = (uint8_t)((t.v[4] >> 28) & 0xff);
+  r[30] = (uint8_t)((t.v[4] >> 36) & 0xff);
+  r[31] = (uint8_t)((t.v[4] >> 44));
+}
+
+static void fe25519_unpack(fe25519 *r, const uint8_t x[32]) {
+  r->v[0] = x[0];
+  r->v[0] += (uint64_t)x[1] << 8;
+  r->v[0] += (uint64_t)x[2] << 16;
+  r->v[0] += (uint64_t)x[3] << 24;
+  r->v[0] += (uint64_t)x[4] << 32;
+  r->v[0] += (uint64_t)x[5] << 40;
+  r->v[0] += ((uint64_t)x[6] & 7) << 48;
+
+  r->v[1] = x[6] >> 3;
+  r->v[1] += (uint64_t)x[7] << 5;
+  r->v[1] += (uint64_t)x[8] << 13;
+  r->v[1] += (uint64_t)x[9] << 21;
+  r->v[1] += (uint64_t)x[10] << 29;
+  r->v[1] += (uint64_t)x[11] << 37;
+  r->v[1] += ((uint64_t)x[12] & 63) << 45;
+
+  r->v[2] = x[12] >> 6;
+  r->v[2] += (uint64_t)x[13] << 2;
+  r->v[2] += (uint64_t)x[14] << 10;
+  r->v[2] += (uint64_t)x[15] << 18;
+  r->v[2] += (uint64_t)x[16] << 26;
+  r->v[2] += (uint64_t)x[17] << 34;
+  r->v[2] += (uint64_t)x[18] << 42;
+  r->v[2] += ((uint64_t)x[19] & 1) << 50;
+
+  r->v[3] = x[19] >> 1;
+  r->v[3] += (uint64_t)x[20] << 7;
+  r->v[3] += (uint64_t)x[21] << 15;
+  r->v[3] += (uint64_t)x[22] << 23;
+  r->v[3] += (uint64_t)x[23] << 31;
+  r->v[3] += (uint64_t)x[24] << 39;
+  r->v[3] += ((uint64_t)x[25] & 15) << 47;
+
+  r->v[4] = x[25] >> 4;
+  r->v[4] += (uint64_t)x[26] << 4;
+  r->v[4] += (uint64_t)x[27] << 12;
+  r->v[4] += (uint64_t)x[28] << 20;
+  r->v[4] += (uint64_t)x[29] << 28;
+  r->v[4] += (uint64_t)x[30] << 36;
+  r->v[4] += ((uint64_t)x[31] & 127) << 44;
+}
+
+static void fe25519_invert(fe25519 *r, const fe25519 *x) {
+  fe25519 z2;
+  fe25519 z9;
+  fe25519 z11;
+  fe25519 z2_5_0;
+  fe25519 z2_10_0;
+  fe25519 z2_20_0;
+  fe25519 z2_50_0;
+  fe25519 z2_100_0;
+  fe25519 t;
+  int i;
+
+  /* 2 */ GFp_x25519_x86_64_square(&z2, x);
+  /* 4 */ GFp_x25519_x86_64_square(&t, &z2);
+  /* 8 */ GFp_x25519_x86_64_square(&t, &t);
+  /* 9 */ GFp_x25519_x86_64_mul(&z9, &t, x);
+  /* 11 */ GFp_x25519_x86_64_mul(&z11, &z9, &z2);
+  /* 22 */ GFp_x25519_x86_64_square(&t, &z11);
+  /* 2^5 - 2^0 = 31 */ GFp_x25519_x86_64_mul(&z2_5_0, &t, &z9);
+
+  /* 2^6 - 2^1 */ GFp_x25519_x86_64_square(&t, &z2_5_0);
+  /* 2^20 - 2^10 */ for (i = 1; i < 5; i++) { GFp_x25519_x86_64_square(&t, &t); }
+  /* 2^10 - 2^0 */ GFp_x25519_x86_64_mul(&z2_10_0, &t, &z2_5_0);
+
+  /* 2^11 - 2^1 */ GFp_x25519_x86_64_square(&t, &z2_10_0);
+  /* 2^20 - 2^10 */ for (i = 1; i < 10; i++) { GFp_x25519_x86_64_square(&t, &t); }
+  /* 2^20 - 2^0 */ GFp_x25519_x86_64_mul(&z2_20_0, &t, &z2_10_0);
+
+  /* 2^21 - 2^1 */ GFp_x25519_x86_64_square(&t, &z2_20_0);
+  /* 2^40 - 2^20 */ for (i = 1; i < 20; i++) { GFp_x25519_x86_64_square(&t, &t); }
+  /* 2^40 - 2^0 */ GFp_x25519_x86_64_mul(&t, &t, &z2_20_0);
+
+  /* 2^41 - 2^1 */ GFp_x25519_x86_64_square(&t, &t);
+  /* 2^50 - 2^10 */ for (i = 1; i < 10; i++) { GFp_x25519_x86_64_square(&t, &t); }
+  /* 2^50 - 2^0 */ GFp_x25519_x86_64_mul(&z2_50_0, &t, &z2_10_0);
+
+  /* 2^51 - 2^1 */ GFp_x25519_x86_64_square(&t, &z2_50_0);
+  /* 2^100 - 2^50 */ for (i = 1; i < 50; i++) { GFp_x25519_x86_64_square(&t, &t); }
+  /* 2^100 - 2^0 */ GFp_x25519_x86_64_mul(&z2_100_0, &t, &z2_50_0);
+
+  /* 2^101 - 2^1 */ GFp_x25519_x86_64_square(&t, &z2_100_0);
+  /* 2^200 - 2^100 */ for (i = 1; i < 100; i++) {
+    GFp_x25519_x86_64_square(&t, &t);
+  }
+  /* 2^200 - 2^0 */ GFp_x25519_x86_64_mul(&t, &t, &z2_100_0);
+
+  /* 2^201 - 2^1 */ GFp_x25519_x86_64_square(&t, &t);
+  /* 2^250 - 2^50 */ for (i = 1; i < 50; i++) { GFp_x25519_x86_64_square(&t, &t); }
+  /* 2^250 - 2^0 */ GFp_x25519_x86_64_mul(&t, &t, &z2_50_0);
+
+  /* 2^251 - 2^1 */ GFp_x25519_x86_64_square(&t, &t);
+  /* 2^252 - 2^2 */ GFp_x25519_x86_64_square(&t, &t);
+  /* 2^253 - 2^3 */ GFp_x25519_x86_64_square(&t, &t);
+
+  /* 2^254 - 2^4 */ GFp_x25519_x86_64_square(&t, &t);
+
+  /* 2^255 - 2^5 */ GFp_x25519_x86_64_square(&t, &t);
+  /* 2^255 - 21 */ GFp_x25519_x86_64_mul(r, &t, &z11);
+}
+
+static void mladder(fe25519 *xr, fe25519 *zr, const uint8_t s[32]) {
+  fe25519 work[5];
+
+  work[0] = *xr;
+  fe25519_setint(work + 1, 1);
+  fe25519_setint(work + 2, 0);
+  work[3] = *xr;
+  fe25519_setint(work + 4, 1);
+
+  int i, j;
+  uint8_t prevbit = 0;
+
+  j = 6;
+  for (i = 31; i >= 0; i--) {
+    while (j >= 0) {
+      const uint8_t bit = 1 & (s[i] >> j);
+      const uint64_t swap = bit ^ prevbit;
+      prevbit = bit;
+      GFp_x25519_x86_64_work_cswap(work + 1, swap);
+      GFp_x25519_x86_64_ladderstep(work);
+      j -= 1;
+    }
+    j = 7;
+  }
+
+  *xr = work[1];
+  *zr = work[2];
+}
+
+void GFp_x25519_x86_64(uint8_t out[32], const uint8_t scalar[32],
+                       const uint8_t point[32]) {
+  uint8_t e[32];
+  memcpy(e, scalar, sizeof(e));
+
+  e[0] &= 248;
+  e[31] &= 127;
+  e[31] |= 64;
+
+  fe25519 t;
+  fe25519 z;
+  fe25519_unpack(&t, point);
+  mladder(&t, &z, e);
+  fe25519_invert(&z, &z);
+  GFp_x25519_x86_64_mul(&t, &t, &z);
+  fe25519_pack(out, &t);
+}
+
+#endif  /* BORINGSSL_X25519_X86_64 */

test-generator/test-generator.cabal

@@ -20,9 +20,13 @@ extra-source-files:  CHANGELOG.md
 
 executable gen-tests
   main-is:             Main.hs
-  other-modules:       Database, ECDSATesting, Math, RFC6979, Task, Utils
+  other-modules:       Database, DSA, ECDSATesting, ED25519, ED25519.PrecompPoints, Math, RFC6979, RSA, Task, Utils
   -- other-extensions:
-  build-depends:       base >=4.11 && < 4.14, ascii-progress, bytestring, containers, cryptonite, directory, filepath, integer-gmp, memory, random
+  build-depends:       base >=4.11 && < 4.14, ascii-progress, bytestring, containers, crypto-api, cryptonite, directory, DSA, filepath, integer-gmp, memory, random
   hs-source-dirs:      .
+  c-sources:           cbits/curve25519.c cbits/x25519-x86_64.c cbits/x25519-asm-x86_64.S
+  include-dirs:        cbits
   default-language:    Haskell2010
   ghc-options:         -Wall -O2 -threaded -rtsopts -with-rtsopts=-N
+  if os(Windows) || !arch(x86_64)
+    buildable: False

testdata/dsa/signL2048N224.test

@@ -0,0 +1,909 @@
+g: 6907a072b81862e4621de1cf1173e5d7b26a0da7eb3877a3fd8e5160e1f3958287f25b8e55635bdea4b3a94282a49b0b89cd962dcd61643bd2a8da0017b85476f951101581c893d67058f0ca37d7bebbfad0857a5f791fed2f505585cefd0839ba2628bcf409e6ea5fc7d2fb709dfd248876051807c0e1dcb5eee9b96c43e17db13f0548b8e0416a764240a33352050f7fd06c1f3fe3492050a6bd1e5432b03b2af8aead27ef9dac53134021478c9b521a41f52f1dd52a6a7883816535ac4057032555c9991992ce65e185fdbb488f9bd6b8ec0d5425df81ec9403b2412e7b620ccd82b0858467902f60d7e0df054da343bb30129bec45ab73ef62f0971fc45d
+h: e0
+m: 5b9e51587484af8c2957348f419848441ba271829bf358115919d834092df9e2a350af38c64d0e1406aad9e2af9affd112a22420e4230700b8d4579adf6b02f2368eb676a8682506a6c5bf21519605ae47963372eb2cbbab375c7841b7432da5d13ca4b002be02b9be001deec4d7083599b0226e5e7cbaa43f2d22556761a2cae25eff4cd819084a68fb4573dc46c2663e9ce12b0d648e4f1eca3b8197470361a2ee2d284a099feebec8a377662f38443007a9fb1498fd1f179627ff0ab300c2ec2e2050a8f109d8b28d295d983ef88568996b3642eb2757f3daed5109a94fa426cde7d4d281d84bc0190617cb86
+p: a4da0f697eed92e72fabb0a538fbf690b7809086a59c7f119ca18dff733699f80f9caa59e9630d9aaf90c2dc17add835ce54197cb95269c3f767d68e5d5e3dd454fccc7a01816a588ca1f4cc7344b20e457c32c4557061f46f6736d932cd5eac60c05ded929dc8ebd9082bf685e478b6bd497f653611e9f8a8c10aaf2409136ab5b5a2563363ded71303e66c03f9a6aa70c19b73def6868c40ed94da2cb296f3f36ca060884c634b69c5e3622767ca6e8b7c8fb81991a5ffabd7aea867b0edfdba5e6cfecc13262a290ed4069116150b25321390bcc19c95c3ca42d0bca04e9012f4f828964fc31f094c032235464a6649f0b222ad86fba3ad6ceab8d3c4c5c7
+q: e09ad72fa8ea898997ab1894288e16803641f7f539089414bbf93165
+r: 5dc513689b5bc9cda535bf07b3c06214ae12b7b2bb512496445689db
+s: c463bd68fe6d7afe144dd62530ecb62c0b084252fedbd3a92b8473b
+x: 1427aa251a0b4ed1c664134bd4e7a69e5169ebd225b16de51febb5ca
+y: 641c6c8808db6498a3ada4fbf9b3bb84071f2d5b5da68296fdde7f6274713a3ea244e0a6b9da75941d8f36a706df3384d473edd5681e9f9ffa6c6aa3bfd4ad77d8c1164fa2e4f46b3cb07e12dda96c2cdbe80521c459a1c5c0a80ab8f8b5505bf70666b56abfe21ea5f787bd9473f36cafd457c413c9d96bc24d29ac8f1d5defa6307c0bbc45ed11b65ad094257de972691e7dca315bc0054d6ee61bf2577fb190b13f0d4b07bd25a19d6b0913c47844175b09ff0af0344abb08e17736df0e61e16f924c04d9e9b990103ba2926dfed2451c2c79e91b8f863333207ebfa3237be0af3661abbf4f4a98cbb64d1f233a3033fce05006ab41d30072348439a38475
+g: c768c234f7113f2d1631b5642275bcafe0a819d744ab8bd4f2f1d4852873b5c7ce22cde75119922239dbc3c6164835efcccb9a1c41d8f2db1bb5e43806ea1940d69e6439f5015fdf58f638d83b57f5f1095d460fe33fb07dca787cc02e21d890cf80e4f13f70925f19416568f90721e1d1ebadb1d6ba40ec528f13b2b2a91b85fdfc3cccb18d49b604b6d93ac61b092e7c094000ed34970ee12934512c394f0813f5be8556c595c2d550c2dbc35730134673541180a757917af95dfacc2550795cf53ccc6a37cc81bb8c68001198cea59dc908c5222b8533e22c08cfebc1d2355f64ae7bed6a4883c60c5aeb3226d0ef2703051d978af5d972318a5fef4d14c
+h: 180
+m: ba984e8297d8acde096f55bd1fa2b4aed9e5c9dbb3160d5dcf23fd6c29a5e7b71b4e120d3ea07c908c57d0e0104d0ed67c2d41db541c0e19076c6b490cc55cfcc6ca8bdd39f5f38c4200bb15671cf9a0bebfba5d98f76306f436b9ad8b90545402943457895e3543add17f8a
+p: c2b3b3adb34dde06655d9dfa8f1f24f909c21a04dccbc33be3c31ec0a0878790aff2e59c8ef8a62e0a50a255569c20a5d38ffe80b876026ec0bb5aa49fe194ffa517b30400dd67b85eb37af2026bc66f659ed4fd60c271351e4992889b163f236e96b2bd9ad5fef239d32afd7699fb8447745ef6c26b4d66cd0c5eba1713d952b752f81a1bef5ffa72e6402497b0be3c88811808161d43f90ee8c8460ef7d5aa52959d8239c29d1f531872f021a9131d0f39120bec78624b159a3a4f96add0664729b549d03403498f81c4a7023301c1b3c4aa385b6c303225027eccf1dc010547eb497976b0c7f6563e37630b241195b5acb7ceaf29cba227d85906d4d10935
+q: a8bd009d9dbe5b8768019df747b7e38a5ce16d1a0aee09a7c6dec609
+r: 3b9d8fbc9cb3797092f2ad0344adf53484b8fd67eff765d7a68a3822
+s: 2817e0ed023d5bf966e8d88fb561ccc3b13297230ff7f2c5594ed961
+x: 9163bc5989a16068b8893e0b5e2b72b39f65f5f016c690dadc7f95e4
+y: 6577c5494f307facc9f559769e2c8a771afb746a1bd5d479d3e754bf6e5a8385ca92b0e610266af4a910535a26642ff6c9c56bdc366a2e4de634699b9725e523c44c6fe3cf12107cf8cd341be17916377a69e4733dd079ff03de844bc2c1e76e650292cc946a6905ede6c0ce0efdbbe22061d7b15acf3c477a81a098fc80fedb9c0a70a12b9ee78b5059fda201c80a547d5357e3dfa7fea7e3b5e72680297552dfbf5e78da3cb9c2b9bcf94714e3e419ef07348f16ed7dd1dc84a613b2a468a1568e3c9e970c8623f15df26d2e9c3d65646e1f23dffc993e49128b8c74b1542a921268a66e9563b370f6f64d274630525778e2e9ae8124d1f899bd81eeb2d621
+g: 7d427bf9f9882dbf7481d2d039e35e120b3648e91ee188104328408a712d8e4a0577be1142c924298e202abd753c0446a76ba79623db7bf25da465e9b289b9123b670b618d2bdace45205494737485398e73805fa929727ce8a6c7ade0395883f058a29767d67f48527bea1979b2c406e790f1676ed97ee5f23d4c231dd41b54d695fbc80916e5ee5e773cf33ee4ebff916c4cfdb47ace8471839e5a238d382095da9b4b278a64bc574cbc9fa6f255ce593489147c847f3a81856396ed344a0c42dfae9652fb5b2e72c9fb04af9a5d35b336293b5cc5f66f554618a7d01a4b2828690b106a60825309dc5dbad5052f9cd67095ed70457ef3c2a29c6a5c56f4a0
+h: 180
+m: 4ffbe6d0764ab2c15c2f75de350d864c7fc415e018ba66074edba720cc216072c9873ebcc24d7a31ba509bdec09df116e4a8d0110d105f0e67987865ecd71e89d96dade9715c89e74fae3a825cbe2f32e8fe3adabcb2ed202378dedbf2e047b19598aba595198c73d9d4d41c522f2f458ba2feda71916685d1a71f6c1452465a88fc698668b740ec47cf6b6b09936fb5fd4c38cca863c6928d00a050d3a6c8d844137f76518932726b1daf928ea5f1dea7d627ae28e0baf5c79925
+p: 88187c27193ff47f07217ddec8a2a5f8f1f8f7cd3b7e4a3a55377a72046a3f7c73cfa7074b063cbdf37623b620fa689350b134fce801e6425978e392896523e510f52e9b6e91b69540c864171ff9125ba1324f81e54f61d1d6763aa6800c999073c4376001e0c11c5bc0f6ed40a670cbab29952d6143621e5f89d84c4e507d32c9dbae5f9a469dff0550769e243700735256bc0454a57754a03354a3ec17d8c90b5e3136846ef5cfa9105fde352820e7df1801253988a0bb89dc083d7925ea6a6d88f80010638e74492d28009f1cd43ba7c645b61281f7dad9ca79f12430183d57768567081bf4c0e78dec0933d0d3059ac4d7c9e9e45ced192f4d37ea2b8229
+q: c10ad68517578153a8c1017498bc9d1dc6e57d6ac35a7c44dc4c7465
+r: 5d0d48a16093a71905e49909d987552b377ffab255bfda2329467125
+s: b2510cac9390e93268343a5fa44d1fdb1ade28507fc50022f69b433e
+x: 261d755051573c27c936e9d9fcd3f166258f03eb85b597af373ee9cb
+y: 78f47e1998cf8d3af9c5398ad2b0f9f58f2e8e85428bf19cd9fa77446eaa58aecf2a5c33c7b017bdc4877694845b86243d4a8fe451276139c4976b0ffc402f7b2c8b160350d03257ed27be57961d3aac3b603b898345e1bf0e6c1ba92215339b3333a6a5de65b634e004b431026fe8061ab0986f73d59c36c99f63ef890bdbbcdc0af97b27bdc729d5dbd352070cb973b7d9cdcbff94ddad421099d7158c7bb949d87712b21e02d7d32666b402c60736780f3a223482426cbf2da6ab42766617fce3811cd9ca680e972736758e795496c1b4b8d8f577b21517dac2986074c029785373cd91dfa554e13235e237c35f9fcc768f7e5670bb7a0a91d798c94b98ae
+g: 78bc8a7893ba31c723f2da3d0b692faf29d7fbd99dccad2ddfb5ae5c413164eda415e7fe79d871c7f93a88b5a26db029c589f3d1d24d766a31ff5a29a85de53e50c183b89f79e84b0d68802afb26e908275a9ce7e226f2fb8eda25f0d1b4294483389567dafd8fccd579f8e76510605b5ae0586fcf7bde4c9822abffbcd5cffe40cc0795e1c5def5ac44acc1851e103c85a7d359d11c7f9fc947b4f57f815196e37a61acb5aeec5e0ddf2fcce5c6d73638657375a4b0a0fe10b0a0002e3530c6b8ee77981e00fa788c57625ef939432203c59e3dd7df9418e752253507c04b99052d1309fa0a11660be9dc8ed7933b090b9ac662b7f15b3a8dd56463b6a78726
+h: e0
+m: 0106de135125a367dc073135e6e1dda2eb382640278e744084ffde08b11207c6565ea2f71fcc1ad1a01e91203d04604b1281535b89
+p: a3a1d7b36890afea91ce89277c435d91010cfee2912360245eed827c8ee1bd495edb53840716b05baff2ece3fbd1838d50546b8d4fbd7c6ccaefa02a7cd97951a47538133f6a4d11242245d94bbeec515c4514d0a60889b9e5dbe404f9d709b1dc05eb027a48b6ce5317c7ee13cb4657452a2842c0ce641588a12c5e267c3c66665e831967137e0c0ae8554302a4d3a8a3cd4f21ed714cfd1b64b2c6aadf3670ca788f0f1e114db1fd498ba95b559fb7a0872833b81ed420125b044bf015c92fff092235450b840c664e9568dbb150bcb69abfe29c588def8250c87ab850d13dfa92296035270b8c5895101658e863db71689047eaf9a742780ad56ee7e37e41
+q: f2c374f3963bb3122ade6644fdfe852f3d22d2a4d500e1a07355d673
+r: 1e411dbe74af08fc6fbf2df5caeff5ecd2189f6ec48a2edb45b2e5d2
+s: cc68f6d65d8055dba5846b6878dbdaecf55697856df1606886257d50
+x: e330987fe0fc1c57ddc7fdf7e6a831d9cf2de435de9a2daa4dba4d7b
+y: a1fd8b07e7c63c5ccf22467bd773db51d0ab5697da191a5183c56c9f0e3689822eb827ee37b051cc4e7b388ba131d4601508e935d2be54d8ecf646eb9cf547710d9702e507fbefa0c011fb34faa8c66c3dbe49d9119a89f9fa1a963959612b21e27d3552d25a60568d04791f820dca1088754a281ce7592c52487caad52b31eeb750626ef084520a0bf7d930b21da95b43fe5923b9e3ad168d4ed3bc1db16cf7dfda9d847c28f799e0c825bff3ffcbd9883aabe219adbc698896107ff60422d7860d12ab2b85ed7624e89dc79e637790722559e3206c3c40be5fb6d735a9451d538018cb218fe7d93497e2f67e66dccffdb8335df4bb2967d1390d08798fbc7c
+g: d1763360ffcf6795a1b5a5b2f8497c7dfc5e71249be4fa1ed71ff73685775855cc893f6d2d4cb2facb60fee81bc3af511e453f7cb062dcb402667c3a46de52c813afa83463eb58bd626aa796d11498cd6d21826f5f2db796c407d27906dda4e4d01c74590a45c0b46e1087bdbfec91ab23649a530cb7d307bb56eaa4c21882d0c58e9a13c911fd97713302a4fddb9f68b17d4cefbcee5276b1a94f3e0418d72daea19987795d5855f7da8a3f0cad900331512df25191eb8037420137d16c5aba07d374e6f5ac0a089bdb45c134a33a3fd7f168b794fb86dce33d8a69d1971e8249621cf7d9aece68bf7fb81c108e89123a9c1947ef8567346c0bd8774ebf4d40
+h: 180
+m: cfa7665db0c47e11189de1fa549cd0ac5bbb9eae1807f7d372f1f42a2f66640b78e69668127a9f006d6fc6b706a41c60da876081548200fd8f231415fd58653fbdf443446ba527e603bfaeef39eaa07cab
+p: ddf469ed437a720b152d52902bb83993a1022105ac817447788719422c674a943dd3a6d645682fd1b034abea529ab4921514148f8f2dd0b5f3ab7ff39e051b82c643f4976608e2d01967b3465e9c52e3621e01682a884a8348d4ac015e4fdd2d5f82aba74f1d3666cdccc0907205f00866e67390fbf990c5163bd9ac825aaf01483c1cfe1c9db81379d9f924926815bc8031adfbd75c2941cad60855f8c5c6182a72b217a8e79f296ae85257f88b8147cef3aee7d5d260647a68ecf3ae44c273b5a1b0b39b1e9aa4b7487d209ee181bef77fe028487de520661ea985432e95d4d91f2e5a62b976319370ba0eee99c728b59a7d50c0e547615e836fb27ba5482b
+q: e4a7617f540cbdef0762db0c3418d811e41b22111890413ac23ff39f
+r: c71e133201ac408d458ac991af0bf5b874ff7ce8c8e168440b9a687f
+s: b43b4f41f0557f48f2832590482afe48a08724befdf6efe0945a7717
+x: 8f784a294cb67e1feb9d4bcc3c882045befd8b65d8982640e82f586c
+y: c5ca9cc76ce80b5cf48f87726fa1cd43ce2815b536d69551f81ca135001f5e7622d5062fe3e08bc6d58dc57ff925828beb3b2815edb8dc6d9659b5733561488220290f6b319ec7ad328b615b1f91d686eaf03b7a4a0773befb4a03b71932269f7bc6a06b222ef66deb66c7089db6d03ab38c4192333106cd1bef2eecb6a6bab158d666aa415455cc274be6e88cf8e35abe0ec0ddff82adf7a50584e8a2fdde1f139e7a71d63d4abbfc408feb039ff48da9a096b87213bb51902220c840f11873ff922a8aa17aa19c1a945da345d7f66ffe91639070961e145fef3e4ff364dee336330b6f00f7206268d5744da309421e3829f7a22cc20299e01c5b677e1aaa79
+g: 3458c42d21eebb814d6fb13de88ce72da42a9ef0c2ed54a782c4bd241fa5974ed892a500b886696f0f83ce744d893bc65dbb1b61f6827739b9ac9ee33d7f8fe2c04a9fd0cec1b4014988f2bb53347f210796ff829f42704ecd54d62185c26d961f4da1c41283fd47aed672cd1fd7bda0b28aa445bf8fc12747cb8b446a87c237b1da49f17c316e541dcb25013dcf32af99292a4bab3092906a2e6030060da150ef37b71beea078158350f86ecdec84eb71de76280156adb06d59267792416e6f0acd5e1343f6ded51d93b28e5616df3048200a7138643b4c471c3b70c325bfef33335f8ef308dc6ed32cfd686a2eddd61fe8311db5e3b73a34701b38e2e6e190
+h: e0
+m: 96c67b8bb4b501d75f27dcfdad9373794f094911d389f3835e30401a1dca55a3c709595719e7829037f709b2f69a96407afd3d0e3c809552bbe06224d5f6a792e1f1fa6cfc9c5f7912de6025565e432730b367b4076298244a930e92d288c979e4dfefa426ef95042ec158308011eeb23f75441ee1f460a02b6332d6015e9253b03b6ea9b82bfcdb5da4bc7d14306b361bf807964e93ba129dfecef67ad19ec58e00cc94b24d8aada963e450c792ba518d4cd341705c95724a76ecaae54a8b05a671f2c83bc461da4587e4288e41d2df5ed0b73dc284a72be2ea360a32fe84f07f9f35074b7923e5d99f2b8f49c2744fccff9a7b00c904a50b92566ec6
+p: bddea458eebe5a8e4c56e3f8a0947527ccf0fd9d2fbc5d911e50c14c3f1eb42a2629cb168df27ea8965cbfdb839fc6d09a9b3255ea4e2797f40162c6bd04e92c575c32a54f97239219004f3eccd9c0fd81603a9d9857d0679a5f4d907432f3c519a9141bca37acb5364643d5621c2661c01bf2d13b77fbb9a80797cc83cb9b709796f8761edd1c6365bef02dce356c2ac8e0c499a12f05cccb1f0701611113493fdb0c3a23a3b16548207d057bb66c53c1f3323f29102c507f12a134731c2e36f9537c2230ca48181e63c90607fc9d72bf8c26cf0cafe10f4f48ceabe9fb62b298da0fa0c09395343fd963ae068524c48435489b591e54d2a40de37bc918891f
+q: f59d2f09bfa964dbc0f75c4ace3e5cf76467ba4992903e4f57d40dad
+r: b151d2bc3d717468e7afe96d3240b0e04451e83d18b1175f356a8322
+s: ea1b98ba9c3d1db3d2a39d12a6e072590bd3c1cf9c13f41dec37b665
+x: 3cab737b8a9152846d415eb7d12e0a58a3921873dfb5c0b0f655e6b4
+y: 9e778c13495f4366591a73ac40ad60fbe20be19e0f5c94c2f199c77a7dada74fa664509008a2c84bb5e5539570e2fa6111cc5737999c6f9aa54518aeda5b15577000f73f95c020d952a43bbfa85da8706d1557db5e7f38e037827d86984587df1ecd30e959e15d4b5a5c2bdd2242c08d267eda61e336b347bfeed9af5e5ff8c93a8141f85cdb4da78457cbd582aa95b86006cc8da3acca75e62fa5c1c091c82a88b247c3c8841b2d2fc5edf86496e71a986a5a8c63e878307c95098be4d0ea54049a4cd20935ed8a67c2aa7b76ccdfd39da27ae5f837e631bb6efd266f01db05bffbd7ab326fc393698c4efa5a12232a8184e67c62628989148ca02c6421a8
+g: 15f4ee8c927a4d6d34bb475aece2ec3c98c4a8638b00df91cd35e7bf1e4396312e415ca1e235741fb174680c48bdff9ab22bf6fc34589f40b1b8cc8d4fba685f73e34fc5fda8a2c59d3e7e65d7d7c889d6f55db2c8902c98e79112b733d207538f1a5d47c37c8b7cccfec28cc1bf77145dcc491724cd7373165d9097675ab9611ea77a694d494c0c85e80dbc15e0681a7b7502e884e37a41c465268e2bcecfbf1df5fde45323e37b6b0d505be66bd7ba7f51d61277b9e595c79f5d87dd2a19dc99b76f1036c2eb560544e0bd122790a342b0e6fb150c2671c714659f2d3185b41d9a676dcc01277915c06c0ca9f01b7b4a988c6efcc3e48b280607f396c12f36
+h: 200
+m: 13fc4c9c095c832ef248f8156ffe24ceb6c7566149e0ed9000a59a5dc40e14a365f54ab36f37de938a848feb1f5fcb9c825d4a436c4da4adcaf0d81de0489bf6f76e280772fb9596d599ad99c0c879a302dd28c45ba2fc24947d06f072bfd2c5f786b1114d1fc24dedd0ad60b6aed4958ea3d38ded60720f7f0291e888c9bfdaa327b0ee94f4ca179c278cb1cae9e6c3bc88c6b0c13542d2396478b1b53eb014a862119dcc39b4c0210d6a7ae25072ce9c62ef64ce5bc11037976a8ef8f3607bfa177d8c453240896121f197b05d7f73de14a88b5f2a1b268915d32f710169a45c8de18bf160567f15b753
+p: ae763b0d058aeb7340b9dbdddd3b293fcea5a3aecd0e9a040da0aaa50af8e23b61d702a50a2dac94246fd072bc1cbfb392caa751050bf2b6b1dceeb0203992875e2c58964b6c700b012cd1892d49832f3d5b7ca89bc14f76e39fc907a023d8be7b4ab3c0718036a1d7aaa9088f122a7bad91116db3d003c2bc631956f2ec36a5968a502977fc700df1c9722af40ad68a6c35e0a60dd8203d8c8f188639c68f6ed9cc2807dc2f0a7db8bc51055b1813d88018d8084f68b79352ea414e18eb2dc2e955434e53816540201dac1313f00b5c653e42e5247fd61e649c5b1c2a801189a70d3bd91f52a6fd9fb155b2b8747f80b85784497547fc1aa06e974b62a961f5
+q: d0b2c733663e539712204ee1222e5544660ffb6442706ed2232eca39
+r: 6d3720851b5f6bf357db368f90ae422979a71b082639ec2c1e4afa
+s: d0231900db79b9d703045ecb7952e8519706aace60880d49a253b064
+x: 668a3d8e2f3a6f43ebc4875bf17bc3b2214d09717f4609c79bbdeb29
+y: 6b08999e6aaad6fd5fd164807807cda47fcd26e5989c309ff125f5b9567d4e2a828d5ebfe5e6ca18bb0f61c9ebca4a90dd5a9a683a4f8691a28394a702a4bf66527b48481350e0ea7f8c182c56ac150782fa6564a8eb9808886fd7173bc256490c0575d865741db69667496ac0fa7f60215735447efea631f3fc703fe0ead05fb5ae79a919efcf9fa26cfa2b2d6052478c82905b4f57061617224d5e067bc0ceca0f1e31a1ba62f51f675964872798495522ed0b164338bece568f6c60f8b6923c8454ba29c09287db0dc62460e1e93b334394216bf7bf08ae6adee8d34ea387786cac0195af0169cd0c4af8d62a393c8f2fe1dcbeb9c800b33cbc76adfeb118
+g: 56277772a87001d18e8f82a7f0505ced957509d734ada4254d41d12bcd5f08940a03878084f84a391d3e05861c89930b969fd0b2d20357814bf18d8264ea74eb0ab7340f07f73374f284f4b4f839099646bf5164dc24658695825380eef0268ec2c23417e4211e58709ea9e0ac3d614800b5172b1f57b4ff1a25f3a7ae27eedb660804910c5614b8b9dbe186e9551e98a5cc085b252abfca757cca0c1ea04472ebf37ded59f21a20b5d553f8d4a1b8fde1956e0ab524d176c82d173103fe16a69870209b3803ef5d3ece9d6e8ce2e5b2df3f192d7e55cce41fba1a6c43cf35d96047a4207cdeb6c136ff0a191e1abf434791615acf30b76b8526760dcc6cd33f
+h: e0
+m: 8157b242
+p: d4c994b7c237829bbce90b5e5a57c6c5b100e8b1b910d95753123b7516e4aee80584f4f9b5f1fd1995a472af28d4ee8c9d765c6532fa91ae68a18b801145f18626542c32cdcb3d1aba136be39bf2943057259da6447ad010a4af30b90130f69d55863d2853a429e2d5e6337690126bd8d111629e77f2d383fddd498491fae709e75fbb7c2c9e0290cdea2ee9b6d457cbdf24cf4a9db923d901d439b2ef4033a89d5bc7921ba5580bca2b6df4dbabfc72af813fe951a1ccf4486c975e50259aa9a55fd3493eb3151749b5496fdf9a970f23a85355573d3c57d8fce8ebe47139c1a9045ee6053977bfc3e9e3ae16625dfedf0197300c8e66076821fab5b67ffd63
+q: 8f926164d95fb8192ab91392d0dca1614c7498cdb6ae7a8a21cfe2cb
+r: 878afa4e315752102f1293429c233850c741f5c71a595e521b6c4a1e
+s: 8e2f4a720594781eb0243b6eab0baf4557ba4f4540c7818f91878ff2
+x: 4983fc5e78698d863e274caa663e1c89f45c8e6a4c0948a8f493f99b
+y: c23cecd73b0c1aa2d9023c9ddd1bf00379eeb905bf65f119a093acc11f14bf8f5f5fa13ad0b67e41d7fa84445696cdee5bceb349bc7c91942f0b4b83ddbe19e5543f2f272926d2d5589884285093af893113bd90632aecdfff1be94d7bc63d85104adf4db392b5fab1b20e70b136a24a5bb46b8c3ba643ef57af594252ec3725f8c90041583db7ec945efb459eb83a1a9bb5c7063bdfa9331e189cf5bcf09f5f85464efe1c1ff8c54f375ff15c7df50d25e1e881fc483e5abf96f4e1df2080fd1164a88d5815439a1aa0a35785890c650babd4ed9a43b1d5c2ca1f2faa7e431d949e0304c56c2d8b915b7d3e280f50b20d0a482bcaafa58979bd99e56d9e5003
+g: da2e54efb7e2026ea65bd56e711a6b8c1084162515d420b5660b3f1787137289bc3496bc94f56414a74cbfac4b1758279b2d793a47a8200c2ea4441128b3c90c64181993aa41002d32f02e252a8183f29cacab842685a5c52c72c952d798d1e33ec67460cb4bcc55de15787d5d902de4238e354c24e74860912d7785e3647454be060f98d64a92804851ad4978c3d295b2653ba1fba2991e2f8947b7a4ace37e8d331554b59889fe5327a8cd365dffd8f44b983005715896d76c6f20471c707064b90fcf42aa8deaf6a089927760fc1a313b7b60dd2cfbb2c78f475313f1f9677f80d66858d6cdb934fda4db96301044e889d52c49e9f0ae967b8203935485a
+h: 100
+m: cfb318c85f8ce25678d71d89d580d08a99d40bfe1244b5c9215da177ac85e1d700a023f2c2c589ae909e092d4bbd65d6bd14cdc708cd5fef2a125bfaf360c98657a7f127aa6e3a2841699384af023a729b75c9fc97173b577ae9cdd7966fb055f77dbd646a2c844ea3e6321a708509073b593359523dca1b1851464f004c72ad76059347
+p: 994957ed456355257d990c606284083d1b22e60a7032f418382794249c6cb75ba0fa02f6f13007bbae58c29b5b4be0276c25f24e98c8826e1cb6aa559460ed878a787ff641905afa4e5c65ed054ae521ec50a6377b1d366cea6c8255539acfc4ab66ec20784e9a8ffbd735448b40959f13228f477ed6bdc149d736763ba3c3533873ae587b9d1aa08ed105847e81934c55c3a285c9dfa52662407acc47cb9c128c989a52e052e35eb21eb1f86bd31f1f4debda27648838ca0a1b76b73f0eedd9708c24d5506fdb9f4872fe7963c804a859cb14432a7775ae35d1c6566e1b5fcd56c2a7d618a944921133e757a981e99bf3448d42df97e4e01b761dbe2e57218b
+q: b1a6f6afce2768814ed36567ee873f5e8ac74c1456968f3f453c5b71
+r: 34f23ce17b7db4fcc11549354c7e8444c56c864d855a0c5aa8c1b819
+s: 32fd0a7926f2d153f5dc3d223936c48a454afb0af6c869242dc7c9ce
+x: 62184cf9cbc96a78ba1f59e45521cabe2b84eefc166d76885fba040b
+y: 26ba1bf6e4e63a0a1c4314780939119904fb7696978aea62db4bb7d784b2d9cb0b8a04eea3112a0b267a7049281f35cb6d154e05f8831ff120b16821d8d3ba07d4b3bb1c164192f24873619cf0dddb96cbf641ec49dfce7497f4ffba9c28b2cd0cd8e8ee9615e6db13d47db71ec767da8b86f9f6f4242cc8d37c0ca87638c4d19b5c24aff40af45580704b89f617e9c8fb40f4180789b8d1383aa956e3371b877e9d0da257cf07d3270d2d1b33f04cbcd414b1cb6c884d898a05ccc1fee967a4f57b809dd8f4783c4bcf2e02a2fc02a8a33f1ffdec71d03e804066285d889bf950b82c9c8c658ef7a145cf62e9e50d652a1351f5e38850d41b7259a70da5c72b
+g: f151f776685c600062aebdf313d7c9213528e650c64ef864ff04d84165011722e282a787073200c98124ca93d770702acb9df26119b3b676e6b5d8d967f2ebaf51400eed1f40aa22887b2e5870d15646c1df235cb88dce1dee6986229835a5d5f5095b3c0ed9ebcd06a757b5bd08adae8f747a6e2aa763c259ed6d6cc704fbb733b692d121e00fdb0cb4009c2791e8c44e14ac88e903c59f2e8328837f45f4655b7afb2cf35b5fbd0cb6f75a54802fa499bbf6b5ada3dde23fa58de74d0d90cc9a621c74e2071e09fdfb5bb600ef3e74c18bdc985f7ffce2274a78cd73655f1acc8008b328a37bd10a915c1b22bd6870a4e5106da252357a377325c87b5c1f74
+h: e0
+m: 4f93dc748351fe63f11070f67c9958676f6bc1a7d049974cde581fcd123c779ddbba5c99ed6b49d15e649033c4f978e02969e4d0475219c3b003e5666d91b17520b76bc31fd641a0e6e69a9104e0c3f3082b698619ee69f97909b84abfef3940f607cb240011f82ca4f06896128d24d0cd44ea12a98409ff630110828a23718d65876c38ab0bf4ca0572ec6a2dd72035919099e7a08bb6bb86e353065de10a9ebbbc53998fe2cf91bd03df96f4903d0f32bc25c29e98bc8f80691541db39473a6f20c3a6f259
+p: f7cdb3ef93c29b6d8c658e1ad8ba33a15af4c27d9ad61fb8bb3da052476848017a8d5d4039e424f6935996384f8c785f2660c311c604252e1ebf21e0baef3b0aefbcabc55b454757040955f4136f2b1b8a53cb2aedadbb0fe0a83e7f3d1ce6292908a750f8eff73f253656d5dc3d9da6e4d0f9592fa3d284e458070cbd2b969e54957cfa3b0df383ec0ad2cc7a2e90eb5b4b119acae07ce5ee20e1a276f6ff191afb9b7b572e48f375a6d40b94ecb84e1cd08573327bd8b2ec6fc0781a4aac89c09ea50660fbb1778e49b8c927e7dda28470d7567451b0721909a6587ccd1a66113dd38b7d3112d596402147effdc953d594665f946e7935a82e1d9009cf39b5
+q: 8fce73c7d3262f590691379e56c012904c9d71e255f8e7cd2b54941f
+r: 8e4ee117bfdfa307fe29682ce97795be60a6eb3aff2cb6d87baff34c
+s: b97b95197aaa4ea707af995c7e7934695f7bfd971b24d9c33865f09
+x: 133f7e86aa4e8b26ce7a06f7758f0b469efe860cdbc740f86ef13a47
+y: c1e1d6dd155eb0bdf303f2011216795acf597ceb6357a8f861575f31e4f07b8fa75681a43cf221713dd9c090f3781bb0b3cb7e1b938cb5f82b64b1d12cc6082bd412dfd2f40e7bf71a505e418376ade9ef4c177c0aca34a592b10d4e7d2a4c5b45b834a23830a7b30116da00734c1e1e0c890c17b9aed43cc03d2493451717faf04bc969d9c8c49b098f87378d3b381e7e76400a56369734972810ceb2ec8dadbc512c473e87c0e5b52e673aac7efd9535558dfc9e498d764cc0984a95f0b3a5436b3a902efad5c5165bc14c200960fffeacd9b7b3b4139260bba68c72d8ab71992e29f52766fec5759d34327f6b4be929c4680ed9e1ba8e74300c3e030f08cc
+g: 5ef368b11ad0c366bf944c15cfd4c70fa8f1fe90e9e058758203cca00a8e244887ddc0026bc1b7541668f72a8ca7aecb538e62f194b245cb9bba45f61ad0ecdbe045312714b38fac454c891c3415aa6eed8a98d4f9c4f3f61dc1505aaccc527847be612d157f3667178a6ed2b61d311eb4c8b76e559d9be57066de92fb973c2c8241e940bcefe5cf2d6c679fb33022d41d742532a073757286cc68f69ce2ad998f8a68fe89d542f7cd7cb15adc3bb6d36d0009aeddb1461ce5f2ffffa670e6f3bf29d00d7bf5f26bbf13281dbf2f7196553602975ea34603af2334069c0caa8e413b7e5ab87b6bfd0c3081561ec5361ff54eca7c2f33d315bb7067a167dddf0d
+h: e0
+m: 7fb453f703cfb4ac0cd58c459cacce3e28b1bfd61bd64dc9f41a144644bbc07c3f413dd486b67f1f2185ea2a69b994881235356f6dc0357fe1af0526b77b472c16c428aab07494447ba4ade171914098ed4e45b267fe03e2a11604cd3def8e97c22c1ccce2c80cb195707a442e93bcc37329ddbea2b43393babdf0a556c1cef800d7454bd190b6ca2b6f7bc97a0b5a14d757d258825cbd02fba9c54168c03e0ea2d611b8e4486dab547f44ae73e4b6bda08e88ea1c09a7018289e0de28d816
+p: edce55217dc9c0d6b452debb21d239726e94ccf408dd46c4d297aa8bb82dc57c1587df50e8f175de3b56bdd16430ce7514fac777b881598e6e315802c3111c51842ff48e5e814341f433f49d6c90bc9fd54656244252c075399db08b8b16634fdc92adcc5a1dba18f96a7fe19274e05d4cb2c18bfbc83fb4878f0116776b6eb374c4a31b8bb8ad4e7efeff152b426c080f2995ee6342120724143e933d66f147b630e655faef568877c04612e6462350c2e5ce8814668f22b78b41dad71e0ee5ca9a5f7d6b1c06642c098fc114ebb3eaf16a3e3c365b5d50403a239d0b80f6f8da6c6a6936cd26e54dd76bf3735e748d5ec557ade521afeb2f610d163241367f
+q: b4cb15be8eef2b1f681cad74d4199defcd74b56ae88478a2295ed3cd
+r: 8a6c3138d0700b78fe43913d4327a4018c04e0c87faca7b21fad7605
+s: 779de55d2b9988f98149ca5eddd4bd0ebb337419e99d619196374849
+x: 6ae841f465d3299d5a2b49c24bad536841bce0f4df63bf3aa1b850b0
+y: 4b93a4e4d6d9519d98599277cb327ffda47a8656777394badb6cb40c341252b789f4b662baa3a400a1848fa9a763f06063b03b5f9b13291f86ce3b843a7607d4ecd243588caf16c4c802276a415b26f10d608664d1540fd850d9244c5ba943f60f2ff31d7081dfcc55ab236216ae150fba8eed42175e669364372c8edf7118270cb666d838b12fd8d809bfb2e1df3924047d9c5344a0c661764a5aaf2496a1afe807d38a592237968a749334f192a734af11807b522b74601ed164f9a5ae46501add1b083a5666197b0bb747aeca5822f4538c1aa8a0a6452acd56d1a90208a7ac0080b3be6c91b9fa59eb1642cab13e354e8e973997b19249d7b9425d3d408f
+g: 9ee298305aeef3f239956729b303e7ffeb87f694920418d1cf4c68f796448537fe0dea6b8691a0678782d1bf281ee3adf74331d762990f76215e8c06a68d062fda1956200928a46f6121c6af1bcffaaceed1fe8393b432f868fe892920c656b792e2fed8dc5337f502278851ce949106308a9220079e7a2b53caf5f3be77803e0947d08dae62bc43d5e2a81dbe127761fe77bdaceb21a8f7d9f205d58105063e999328af5ad4f06677acf7ac1d972fad0e57df4916298cf3af12e67c26895a295093ac9753b0df758527458834d9aa76ddc282ff1284791ff6c4eaaaf868312c17d939baa70dd1e2f256002f199a757e3726ec0badf8cd676241382e54dde988
+h: 200
+m: 2b41e5342f9c4fc117a575cb933104cfbae195e672af58afe75e9d20edc7d4d685a032f9c2ca8df20580634d688a58c8c13cfcfb9ded2e4f3711c986364773e09bfe33fc8ed2d0463411c993cef870fa72aa8601c2fcde211a733caedf8de994ec2c04336e1a8cf6b8ae26a38db33fcfa4f1dd314d8c571ef13f411b973e87b43ef6a528fefc397cafeac7e48da382cb76ab7d38d24261dbac697073ba624306c2085e8ccb6a832a7a3f
+p: dfbef7a74456b64a7649197d4193f14af9359dc3ed9eb2d0d0960d23039ea221304013c5c2e93c99e320ea978b2c1283ff4fe9e26910f79960d21898f3e9ae449124fc765ee4c52d73aeaddba41e900ce0857da2ab727c81da612edf46ea203ff9be39712d1b6827eaa8515667bbf85b8cd0007c0ce55b0fdbb81d98d866df661b1e97fbc55075c2df562052d2600b5a2e9d5c2e28af568f39f8456100e651a67f301f8e446d72c84360c70f07edb9f83dee1f91c7f8aa3e6e6fe42c2d4a0d67388e51f128ef9a528be9b4badaac524d3bf5d443f4cc4a980e7ceaaf7bf0ac5fa10bd0f0547d0907a48d40aacb874d926c36e99fb350bb2ebe8a75fe94cead75
+q: 8636d99401dcc62bc8ef2aaaf9eac1576f49e0c7794e8c3420489f95
+r: 18633587afa9097818a08f0c48dad5fcd8e1c4a37b07af8158e5b2d4
+s: 3164a29ad416fae98c98084cbd70e25c146082c71e62e551de25d796
+x: 4238a427de56b23d6585e7878c4f5c96b408721073b4dc1b5b995387
+y: ba48870958b29b3a353729e8bdc25612f1942aaaa482c7af2e0aeca884abf1a6148473eef7595b884e57e7b0ab612741bfdb35c5c9a4cfd8c0b1fae8c3dfa1750495eac13bc5a747b9e155375512672adc06bfa0301d2d18b72749a4d37172cd66deb823f51ae06c7a7710490372c9222eea5e05ab2745762ecbeac446b54b5ca3ee5a731b0817840b5591561b781db93e3432a1b4b2a4170609ee7f336f08c619ced35d92a7f87ddaf0a1fd67ebc19cb8e7219c18a9b395870efdc788d0afc51dfca18d709aafe9472455e0329549a6753c45c97d5561481e0c8f8f0a2fbc6204a58f2b1c537475e351876c726134b3c92439f08311b92d1a5522c33e214c36
+g: de8455517e4ef1a07d094e3acc4a0445ff4e3eb0e14f9c1a2cbf9e5c307dcf1d31b3a3aee6776c145315caf9ece314cbcebc72de824929e5c5e287e2e47610199459abe4ea5a5ea023fdbf06afd8feab2b92908a44564802cb90ed0f5d3b5251d3c19bcfd99f72feff70f6bca38f8aef8a2e811290b4a9a977665ed8c91dcc4ec5a389750a412ac1f154efdac00e47f147c8f585506d6849cdc017ad8b070e5f7f175051297fd05933bc4c302a2059e1d63a2bfbe0b07f497714e81374f961aa23c6b8e92e711f6fb7bd67f95dee844d5ec2474e1091a15e54fcf68916b72606f36425722d8a7231ce00075326b27f6048250a96f700674ada91f6aa4f6b2ff1
+h: 180
+m: 09ead7ae2b8bdb6a67735bcccd65b6cd8d2870c72b2712f98523a645547af259f47221d34dcece1c5c84d690eb5054f38e661cdf36626a5f98cca1f1e19ad341e3737b19309dc87152950b549beb52afd901861d2b3884afaca1345fcbcb5be6354b2e25083fc7823ed4d2bb336072827016bbcd4cd718dc1fe7da708f43d565d0b2eca13e216e3ee5a443a841916f74525f6c941a5ed5764a235dc78669ab5de05448335bcb01fabb159285efccab52fe156783ac558c0a4053f6a316921ff123ae5c9b9dbfe1697793cec72612ada8d244f6b8ce64b01d07b6e0479f93
+p: f3ca4b159c95bb71a49ff43481957a2e40ec1a82d484aad27ff4ff8bdc5e7550695253bfbe5c93ec6df799ac13696aa6e22ec839cfcf5fd0c5abfa756bfdcca5f6da52cd3b7cdc4cbf1f803812d356ecda89d3307bd3a4090ac8755623a1e54c85a507589274a4120d2d604052ec792fe47fbdfe48d1ed9eca5b1335cdb470279729b0f14d586a7c4dc143936a59cc79d189346fd4d67d56cbbdbcb8d323105474cd13b3103501c35e0e22d8bfec32949a5d112da299a60ca806737c8782523903fe6241ac4e96da37e1c9ca1a4da38e70a549dd25692869980139b2058e95cb6d3439f21bf0958537a7a11d9f5a316c596c036d66593d14843d5f3e53b1fbeb
+q: 8b9ab58a48cfb9176c8afe98922dc188b0f1b53722d8135f6c402449
+r: 6ef011128d69ebb9124fffda4a3eeafa0a3f536153bcf98a38f25b2a
+s: 177f1bde758e8a484e37fc8bd0af1652069727dcbb489cc399119c8
+x: 5595f26f65958f794390d4568c2cc904790861674ac80bc5a58ff4d5
+y: bbe635c1a563a64573803624b953b002e97ae8268cb37d7faff1f386cad05d9f4d2cb49789645af374d79709dfe7472395ea3274aac73742b707918c620d4214b56bf122cc68c2ea7a4ecf9f582413a3f5500babc79cafddf1033c9fed762844b1c08c054f8798a5c00f20585b940e552c91bb162ae09dda7f25e98844fc1ec7c913691eafad922287080c2d05cd93391598c743893c37215e78e6c2d120efdfc7c3654b5ec3b7a7aaf43d4ef8c4a72a1a9af6f54738351a123b3effa3ed71621fa40ac2cb62e05cd392ea1137ccefbf519e6789e7ae3a478ffdf85aaff2635b679ac934f26e9a45e5bbddeb6e21fbb3ef47c580de3e097294c91af69fcb4199
+g: 917c405a9f89b25636886aa1f82b8a2e68b2bcad17735a5be42b42f491fc7f93fa6bba606aa9525a82831cf961791b6b4a4e6ae8a2aebd80b168075a15045701520aa5c5f4494dab7ab506c47691a2a729a6340473d0d621ad59f3b2c397c4d3d91d99c91e48adfc641617f5765c8f9c229e88be9388dfbab7f484a88d817d921645985d3874d0f7586c8f0354932c329c140af6e03728cea4467e4fa5aaf0db354aaa2679410fd1803f9cecae08df8ad5d60cf916b53d3536da88735aaa662ef79db261b16e8eead2f3561e35aba6c595027053d2b95d8d292a2f3cdd4c9ea414ba2a61b5f6ccbbad6f64dd6e140c47015369a74b10e3c1fb2de91084ded855
+h: e0
+m: f00e6b042477b1b2c4274074a77a138ef76d55bb43fc761588ffa21b3b9562fb69bfde489b5e5624a00943ba8c01c5cbece35eb857bd852a853e1cb9501c53070c1a958b51fe9d95ac7681b9d2050cb0df1cd4fd52ce26d81fc9bdd3ff891ba1de639c0b6bf748f6047d78b3c2d9fd8d0d826dc24b86ddb6dac25ebf71520c5b849813755b7115d7b9f4ed35a67e838c39f7881930b1275f2c0a03c1a37d083e33654c
+p: 993c963c70849a6bb531058a5af8f900ed83e024ed200fab07bc73c2de6c1e1ad062fc7dd944d6f24d94fe1fb44b0668a617b4c4fb10effcb6b399c1f489acff5882ac9980bfcbe9036861280fbcba6134f9931ec39365d50704416d63b395d7a7449326db7c6034b5d430cb3d3a7a973fbdfcd6844100749f93d616e94412ba56144586fc2289ca639f2f9c6554132e73f568ae17130aa7b22af121e9b6fd0d1bbd192f2b21ed0cade13d4764d8d04b407ff312f8aa4f00af17ab0de04e249d228a2b7c9cd214ddf67d13014572d8b4867464615aa3db7ffeb24c57cced95b76f3e79a2a8a80d7f6ed0e47de0b33d85bd65ae607d16a969cb22339c12a6cf5f
+q: aeb0a320204ac1baf1ca158f766ed7b33e899cb1d89e66d32ddf4cbf
+r: 6e6dd782bcc0c52ac77fe203da455c4baf24607598ec1fbdca6e905b
+s: 30f0617a24f2a7367c22aa959ae5e1ff7f87990bb8d704ea88125df8
+x: 969c467dea2510779cadd959723e04f5ea2368e5203de2e7ec933c7
+y: 48fb337e8254834298cac488f5216dd9fb9b61a381366ae9378bc78f5cc435c6f371f61357226cdd6a55fa7a007d544bd515358b31f0f7dc7d44bed29d5a6973966cb13fab3951676aa714f25f5f148bb8864b19d664346b0e45288d3e75b9c04ec2b5866029a5d3b2c62f03b0aa3b3242ae8426e0dcd6e42eb2561dd75a0de7af7599d8f984f55b86db9c8dc8918f5324a8f1b568c6881426038f70e81df6aadc46cbdebbec505e1682d8038932cf1ff4539928b054263f2ee651b71ed379f25f7d93b28bee9f259779d2b234b949e39db7655e6f1d8a201f4573b13e59200e6c3c3d90cc330d4d17fb6485b004def0c071c65158b2b87b99f021d7c735dcd7
+g: 86fcf370fda50f695e9caeb2b6639096842c052a4f4843181e51c7e8111e9d334bcf0db3fe2e8b268810d067ff5958ee29c53407b061ff2fec8f91b638e096bbaa8d4b377ae6ecacd57afe9fa2d3faa6a883e95712c1d42262b6c935401104422469be3463c8edd990a39661ac49e1e3fd524c0f6fd605e9b8f5ca99cd9a1bd905e5a04ec5ded4e04688451bf3e0d34da74911e3bf43d597e287d28d0ff162a1dd8f919476484da8e0e108cf96d2b58252b8e8bd450b3aac91b6a9de82118954889970d0631f7563102d959642b4f885ab5433358dc3e24aaa62313541edacabe19b53f14efedfe5ea36a4b0543e4b9f8a0badec7506558a452aff9131b47655
+h: 180
+m: b337690fa5fc7c9bd62cdcb941d0a64b12b8489895e54e0dc223cd63fef3f73a68d3bcdc7c21fa8ef311cac6ca536127790f16cc4af0d6a7e7864aa5fc25cecaccdbdac7e0a47e0fdbcb29ab28f234fb330c3d1e9ec8dd4ad8781eeacbed60bd83a4bb2635f92f3e1b640474acd33f55c0f070441ec56db72d0b798c4e895a12a816bdd069f0a6ef6567
+p: 9d8d4646c8cf6d8dc8f1356fc44204684af7817ad23479ea2ae98763732ea048fd461a422d2d8dd45284758af1ca7aa8100431b8e46618fa08996eb64ea1f62ec4f75e16297cc511920a4731f55eb7b82398572162d2e0b971069af0de4e201c9e71b7abb46a9b9d06913981a5ee5f12c02ebcbb584d15b27ddd19068369d26e9825a596295353f7fcf9e2026f0d5d52303f50b8b06255d6a8494f61e3a8678cb4786c19e0a0faa3a4c5016c525dc3f7e45c2bd307e129f087777c36d68bac38498d30362b49e648807f78118761fe0c2509e127f9ebeabba37f20339fea7157c8c88d9acdc0ac3d7218e9547b5cda5d0df514df7e9216ce31b887dbc469769f
+q: b715df304d2200a8f37c04abcae398d85d801f211c502c995da3b2d3
+r: 9d1ad56684c4926bf9a48f34186aa9d1a89257639071236247ec86f4
+s: 85229b131a67eecd9755bf0b8c76523d1d9af11ff310b8177bac7dc2
+x: 48e82d075c93ae881c13024cf3007f79182f2d1327586e67360812e1
+y: 3e72e5abef7d3d0aaf53817ce1ffd7afdddeab27631d31dc60be6e9379b1d08c415cb2939e0ca09fcf24d26d0295269f061e81e2c92f6f88c059338160939b25733f285922a4cf2c637d9463b749c9c85ea5110fd2bc4c4e2ad4f4f43b30b0f8a3acae8af35c3745520934c0a6771a3b6f2384a150d8e0b849110f68b7a7121e5d695decd4ba28a8f080b10860dff410dd65d4f004f892249693ac1a760e9c1b59141cba4dd1eaa275f12d6ab70f5acc1323b5939a88289064f45b90c557385dad7fef3f94bda573b5337e3a59aff2c2355527839b7b01813674e1a3ddf3b1aa6cba25611699a36cbfa52c857f6cfec0afec206ae3369103d20f4069b0c04fba
+g: 3b6d588b9fec113a6ff2aaa275ca4299100415bb56492bfc983b13c41d55e71182599e0bc64044d0a42e37f373723f4d243a80692827628d414b8b79dc0e767c9e1233a30245edd7866823c33ea9045826c7bd674ac9b29d6187d5069eff6b798c91d3e8ded61f925728a479811c86308d822d13769976c46d0e44f4cb86b22ba9ee2a52a94c250c0d4ecd826f6e1ddd8433429b2e151524b5357f71d18d4681b9a49969490483ccd2569c0fe4ee4e4267f08ff26521ba6a408f1a3f82bcb5978ff20e13f2aca7c20cdbd51052d0e397501d5cfbeac8388a50e2be6e7800e5f9d747d9cfec6d82cd3d6ef70753c7fe41e766142ae4a242bc32e459f06a1c0bcf
+h: 100
+m: 9b728e1cff164f294b0b076356eb
+p: e2d3b45a4035ff720a751d486730c508d8621d60f9f9793fe3d74ed4e45bee113bdefd2cee4ce9e0ffb89fe06af2cd154a6c13b2e2f6e36cb9803cf0cd6b91267e26e8ff3c837e9c9df95109880f6888086c615efcc3777ca7a033832ac9b6adb2b244124c29d8041edc28a343ed699beaa668571c027ee55aad0d8bd0b0cbaea17f2416a84de912c9966c511798004217ad520a3eb09cb318c274ea93da7c79211977bc1d3fe6078c1284304676130c37948f0b627b85adae56f60eff0cbd3d27282c2e024fe0fb47fb2afaba73dfc248a8650cedf38aa6fb0f9a723b5b468fe5a7be435d9ffa81482ce2143e67d08865677604fee0e1741d6e90f31f71bf09
+q: 8fd517c975c4b949d75d7623ab955d38e1e8721f0c27792dc2f0a893
+r: 57d9baffc630971f47e20009e6776153318adf57981a60071f98775c
+s: 872249bf9a961be1aa2f5471670a1c268ecf2ea02381d1d81f4a30f6
+x: 109e14f53cbaa6d1a8b6570633a801751dc1965326e7c1fbc5dfb5e7
+y: 73fffa4fe5276014f9ac175ac46f46395370db576ea49d83c188889ca2030efb3a0ca57ba026897ca63708483705f6d9e1a81d1e3aa3762b760aecc04ca41b68731bcccc0446c3301c5c5aa1719f2885efac860ab92e29cd78ab846f80b43a52321184cf39444eef379d41bc71c8412ded1c8b346f12e8885a0190b4b17d270fc632655c4d8d7395fd36235adc6f247120e988bef14efe446a56362d77181837a3ca3f40c3d7697b167350ee540100bf66fc2b0f9f2ac5cf09b37968913d82d7f6ca3aeb7df56ed76229dcbeadc448cce7e9533f543f49bd808cd832acc205d63b85a428dfedabd4a54973950bf67a904972da5aa7e620360e2fea5e543cbad7
+g: 912fc3a0c1a61718c9f02c3d01d226d320c1cd19f8c039603e70f1fa9b96678bc3dd459d6dcb0c19b11b29bd387c10d21105248cee9302ebd712897a40423d5982412706aed8b6e4711d48cf10cde866c0604f6dda5a6aca3297791156aa7b7267e8c709e861ae0b4dbd6541755ea5d0c8e2c878740fac4c79a40c253e1563f58946d8ee199253d2150daf4928be93cc232e17a0ee991ea8dbe9ab57edfab127b05013dfb304fcd42a15788e4cda79c9912ad99aad24db8f6e294d0b8efd606356a260432f06704d3d1ca3e5c2cb36bcc04e2314107d751fd82ce4af3112cbb17afbd6faa108c15e276763363d2126d1a54bb7177e6413bfde1dea663811b0e5
+h: 100
+m: 36bd1993ff7d1a10c157b7c4c4eba829e7546b050df1534618e85221df1c1f02184720dadde7c38b80d2d11192e4a262b171e4085243bb3cb6772fe199b9b9a223d3763b16fa568ac738179ebf8503d6f53cb1b7f13ca831057d5562c38ef1260d936e0f80d932f91eb19c727dd98bfc68252bd1
+p: 981a1bd7ba432c5b12e83a3bcfbc18474e8ce9a667301782e9b329e65b2db1824628d6253a57a0da647c45aef3b14aed7578c83e3b7a6c5e55f32bb28dfa86b17272dd5c20e519fe55dc26fd8be827642fe41ccc5b0e3ac34880cb93965af777a18d1ea920cbdd351afb58becac8f135bbbc93df6a8751a7bc6433b4ac7a0866c307a077e70846dab6d1d346dff68aa27e08be32a140ee0317b165456683a5aaeb2f92c95881292326121dd3d3aa957bd158391077837872880f146fd1f4426c9fb8d67c74abe2538422d8f8d4c3a425102a8653ca85a71afaf66373b11e0da7d9dd0ddd96d8848afa800789e88d940785f8ee6acfca57ace233dce65656ab17
+q: be105c46a4e713c87bbbecdfae0ba4c5f9615189ce6a513c44c38011
+r: 599495d3297b51bbc8cab06a00e1d46b7bb766e66f62a34077087095
+s: 5d5c4d4d3412eb458e8e5ad681b1c4c2b12e45455445da12855907fb
+x: 12f4a64fbd200f921385fae808e891234e4c3513ee95209db2b273a2
+y: 2c6b7db4a113ee6933f15ff2063d2145fa803547b8648f828e73c18d548554d73a5a9b3247c8f2fa857209ed46c35e18fc5ae4db2752d199d30767e88bbd1c8ef6b6a7910fe15945ad10a0d1f2cd6cb67c2a1794fa309a4ef00a54e218ea020fab7d7f5a7ef07871388eefe297935fbc1a512241228e281738a8f48fb98da06b5ed06cbc4c59682b6eeb882d51659f58fa79ff2dfb0a924915b19097a66987116aaccc8648e38c976fb64fa3fa1c59a0735be2def2f776dd4900c46345241f51ee0c583932673b7827f3ec5cd7b3a3794d90e19fb9214e9b1a6221f7f63e4aef3ea194b5ee3e39a79dcb4c8cb48195947f62c37670260f48681b79a1d4a4ea8a
+g: 593a789eb79089a5d2c2b8f0801aa6d3a31f53bd55e635f99b0104bafd35d3a8570b3ffe2d6d589443e42842b05a2f01a8b63f33624c6758ec1d43384c15c0092e11ea940afa53b24431ba780ee42e386d41627044a7d1204fa2a7062993fd280bd5a3a91cb6e6b8de1f5f09a91b559f21ff7f84ad8f61bbfea544666c30eeb4cdccff841dd81d3b8f60d7448cb18d6eba9fdc02eb580c4af56f3e27f10078f5d326df2c35f98c73b304835dee42bcb47c7023b8532454b6704413e4d1f9118d8d735678001a2530587bdadc213d0db9bd89b2211ea751e278c7360078257deef5d4ce28f8486b674c5ba6b65c430383b57484b03371792c9059cac7a0aec067
+h: 180
+m: fed4be180727cfb598dc363713fbbd7c7fdaa178585280
+p: f6bd6c0d013d23ca3b5079cd8579aa8ccbc9933c7e33f0036c9b1628a8bda002190d8f8c7414dc438dec0ecf77e3d2327c993521638ad569256bbe69ac62347b3127feb14dbd0d7aadb95d5bae30ae6b6044253113e50055a6aaca8da3dc9dcf4d7c8032427f44db49127516e5fe0f28a32c7077bab15062f427cae0a6d9e176a8719939940c8919d7614137b35db8fab167c8ca2c0e73ad84a1a0842ee2789b23963f449f4b80447f07e4dd77b485143d3465caec4e79bcdbed1acd4528d3fc2bcf77a8e6c30a24dd55effdf743d92888ae7b6a48ae8ad75cd6f4ef2b92d5b1145a24277278427338fa18d4e7068a293e4058ce4e9482695173897309f0f8ed
+q: 8bc9ec7d332642a0d90e0085ee5c68befde929d6e3de1e69ba6a4625
+r: 162a3b83b191efb844bcbd39240df7bd5d06bb27b5410855b49ef8c4
+s: 8145ca6cca9e0d04b7603d666bae46078c1da9f10802a719fd5e6716
+x: 25ff471174921d840b3b58c9ee6399b69ebc0a1d171fa720e888fb3f
+y: 39b0e78f7a72e89cbd63267693b16a6f960dca7abd6e9fe75d22602876e8731141665835fe9141cd418d7b73f028da4aeb4b6d1e2aca3698b97ab37d63a9c2f3ff81bb37e786477e27a79dd3af02584068c4fdde938e635256dd2097e8531eed5f92f89cb71d13d2ffd298ccd8393065f39cf0fc9ea2c90eeff1d4a8bf0030e94b8a19aaa3b677dbf96c4b1583c468d6e5fda7e662c3b0824d418589629c2d9c55a83384c1bc1ade0fd1a4bb8fba46e92146e6dd239d948962cc38bdb96361cf934a1aed8229ccbd7e6eb0825982f41ac4e4a5d76ffc9e8ab95563e2a647ec086bfc1edfdc932bb36c475811593db1a3911245b2b530202da8744e6d3e857751
+g: af72ea87c13ee7ab3923d1d9296fe2a0eddf1e1bc48687de608fae485f72d694cb73dc14fefbb1ef855ab463dd8068201126dff1c3e7d0f2c622f1f1d8bffdcccc44193ee8adcecc35193e30ca36695a8a9a1625b937e5ea82e78bf3feafc2bb82dda8638262090f9a0523d448c68941e85b64591fca63c61464901765c48aab6ed2daff54ceab7d05a828a7e02b57177fd3b992191d520959aeb20926a4ba8c22587ecbc8b6bc5bd01c3e5c84a75409ad80b1271c7b4563357639f45505d4adfef88c29df01497f7e1472c125771bdf09605542aaaa6467ccaeba399a0dad9eda90feabbdaab99cc88300985e298da166490264095b9eef3ff4a5420d226b9b
+h: 100
+m: 703696715c8d31135848e66d8c2a6bdf7925ef0489093e5075ca59aacfc772e2666685a6ff799de4f59e26668ddc2f87d45fb0262c0a1f2a4f4cfcb65ff85319e0f86b095b9cb6bc3321154f180bdb1eadb00730640df30d4225ee8d031d3538b7adaf3cda9d0f8c7148947854e2d86bcdf60b9748ebc51e2508521220945ff1b1fd52c690d95e7ca0bf6339275f669fc78e3f43189c0d72236d70377a6b149f0acb6263926c7ab2392f02561da119d80efcae305d9a860932be5f7b26a5c366d420ca66ebd51d24a210b009b873d3949e3f4061b31057692a9c120d83b81ae8e0747362f1189fa8351ea2bcfd61425d1004e0537c5f
+p: bcc3c31321eb2e21c10028a987f09f5346afeac2e2e9fcc9174d333f332ecc2bbbf7b29e81c8c0a4e113babd61ed3d9212d659bb336aa105215a15f795319af5a9c20fe9a1c963a674f73d7bf7efda95188c9a0024e05116de02356a81bc7bb67dbc5d36a1e903052034ac36d40f22eb71869434edb63c324afaf5248d77b1ac8f8239e9c0bf4b4d13627277f710ec18b17d363e01b7bb5e53570b070fa48a9c42ac1ff54e40744d4120be8f2abd01e47184f49ad81924f2f4f4f9a55f530250a34c2720a8cbb1cda2a192a7624a257f62b57eece71323ca332abea557f84a4e80539ee25eb584517c6de364509c4ca5c33060464d26428088338ebcbcb09a35
+q: a82df7fc9ea48029cfcdb28c062ac1ce63d3dad7e64effcb20130bfd
+r: 61a0d24b7b3721f493d1b392aafc9697ab62d4738fcf6d62e88e11be
+s: 7fc7ccd912d48b8279bb3ce7a8ae357aed7abfce8baaeca53f86b85d
+x: 1531c423cb564a85fdde6dd896869e886fed9263fd1659dfd4bd1bce
+y: 99b6c9d5eafbfa07db1ebf7a3b29409d3aaa34d189d64c28ba3bfebb895f2b392052a50fc60a6636b87c4da6840795877f9b9cd7ed281533e783246bb7e6558d4ae7ea7896e89fe0f22332ff26a1e6028c6b6698df980e1c10d6f356df4cefffa1cab676593af7840b0533cea3b22f25fbba04b7ad5e5cd326a03ddbbb854b787e1f3ed56d947f6cf990ebe2e3786f2d4f167752370c92e46c32632021769d1ee8618ccd8d86e6736797f02aea89d54b3e7d8ed8eb0341a89851117036db04904b516f1501aef8ae2eaa7b7f9399d00a808da3b12b0607e5247bfa88c9930fe20fee5a8a35ebffa9df73f7e9eb7ac8f9429f985190024433cf7cd1ca67d47cec
+g: 25f6ce36e41338202267e8c0f57d0c9b459056ad3b0e1f5c3dade9cdfafb7bc401696a3b40c09a0e8d547ddb7c270017f111ea703dd4496bf65f8efd50f8660fb35ce79bf1c74b299ad86cc31d1164e1fa1062531e2879bd42ddce94a7e32ed76de6282ea3c54ff3e11436e3a5537384edc55811a726fc8e0f330c903c2a98e75f48dbc183be583fa20000fd6f104a6fc53548f9d5b4496782d24d2c1226589c757a257892e7e29dc3aa2f9e78bc5bc589a44b1edc4a07e1601bd2ef8c60adc5a726cd5089f5ffe7df806b66bcf525fb65fea57aa468390f8e408bbcb5abc16982c2f8a5d214d7958cebdb693cc7f2a36d8ca3749949ef59504f264141826be6
+h: e0
+m: 92df7077542fd6cc480a67465a911087706ac3a62a9be72781af054b9b6f9f58d0e18f919d398574afafe1740b91a471aa3098763c686687bb02ab45059fdc1d3b7ce37a3248b2a209f8600d321e9be5b5b1105c8f6085e8a536079b8fee7b31aa9b7df9ab9442738ae9e5651441967ed07ff214812eaa4f0ebbcbb1a35f851a74758dd4ccbfa6f7ad0b64d7e8c1513b6d3ca784caf8580bff403e62b103391ae68c463c82602e5ceecdd01e75e86dd82a3f93e6b17f5d014e0c7be034b746461cc09583a87b58cd8b1b79faf51310f6ea1a32085bad038e91380e
+p: 98833ecb12acc9b5376d36ecbdad45311cfd2b847a79ad5e45c68ccebbc7107ab897fa7027457bf19470907cef8e400423aee7f662105986934bd08a18b89cba7e2a2c9fe12166f5e955a723f9db2379e65ea6fb54adcb1e8d169f2a097156ff804d9342820e99f22bd6b2e23400635ebdb8b3a9231c6fd51f9c27bae18ff0fb16c0bab91c5e663196ee000cdf8d063748e607ed109613c2625b719b7fe53487d6f308af87be99ced8447681ee10844539f16a32019fdcce933ad288b6eec3e0d41a1d1416dc7e9e1755ddaccfdb3cb8f973a793d1ae2b608706b0faad800f8a2d2267b19eb358d611ddf4790bc94fa1c6594294dc7af7fc6bf171b39b7833d3
+q: e9ac0229b685c49b6ab6d17acc399d8a6839f5b0b459310322d76f19
+r: 473ebd5631802582fbbb885f6a7a16116e0955e72a3c41bd851c03bd
+s: 8ddf46d58c4cbbfe9a0bcb4814bd7bdf25ff640b5772cca2eee1351c
+x: e78fd849400a6f743c1c7db13abe8faa3e8ddc53f08c9ad6f33ffd6d
+y: 65a15c5e897ad5452c30e85a2b995c91f258189c3b209b00bfb0d71861ac46350b24a8f5a1286f5d696d3a55f06c010473159bac182a1648a75449771981020cbc7df9715476bdda704123a9958f6d5096ee0109cb1ffd36980c78cf49f2b6833530bb57789d6da675a14bde4f07221f88cbf0991a45e6510c6514440bf3909f9c892575fcb477a45f0fbaf46b074108104918f25b809d651b38c1dea9f1f3bbfdf3b9ae60aaeb30a5a1f2f6f3465bdb4f2e982ec312f9cc81f5156662181ac0c3ffda8d4bfe530b84054f52ce4c781269946ed4f10f7259c15eb24755282a534395a34c5b07a767545e1f26a10ecf0fac5f6bed3ecfa804683f27f3eca919cf
+g: 22b59c4b1153e0bc923534262d2a23112ed8979859ca3ef0e549937e5305e2e5599bb963d672056f18d1dcd3b2fab3433894ac417096ed4a4944a00c4c1a139f61a1fa9bc854c7a6167bec7df7a62d1e303d97b217cb81bf735e9bbe45ca12383ae46829cc8a50753a2ce8357ef453b714af196c6d9ee7b0915b12b5994803f26bcf4309b0e608706e03a36f65adc0fa9cc4cd04b617865af1ed3142a15e409a8bb6efaa23da77ba6af52d0b27de7d8d4bcd623b58d1fa8c87b7c1043128f5155f30b30f504c14d19332ae35ac31d2be0f0281a97a389ea1bb12826b6e16364cb99064ce6ad413feb98581fc702a2fa6614be55967a28506ae55d84575da12f7
+h: 100
+m: 68d1
+p: 8e6b74d1df71a5fb988ecb8fc7f47f1e8cde9c3cdd4229a3a82f24a869f2f2cabe6fd6e4cb808f8d94ef56a50ae60dcc93ec619ad109cd7e0e195416c6dd46c34d59050424f56405536c7c571c31d4b81fb79da08d59179769ad5aacfebbd1c5d019fe61907d4bbc8914a34106418d81360eb122972a3edfc29b270444c4fe5e5cdd1587a064c8cebab7cdf47e3ae3eed5ee825d51a3a558ee6ea43f1d79e069dbffd51fc941ce30cf1454d11c9a2fc0c9a76393b52f7f11e51ae580bafdf4b10e0ab4494d5acf8aeb6fe38e039f53200370697e00585cefbe118920fde6b95dd004634e6e941b900c81fae878dd94fdbde52120da84c4a6f5ccdc0063e59605
+q: b0bb72eee2fb0c3b52b3b5bbcac8ab2214ee726d355e55931c36b371
+r: 2ac98c521a10fec2d04da7ff8a2c775d0b20b167870724c36f82ec0e
+s: 324a6f8ba8c58dd8c70cc6dec279e17d62069633254b2a1513456f82
+x: 3277affff64d42a70e5c49e3f03873f455c6fb4eec020b8e0153e5bf
+y: 6a6695c99483e5144fb46e415390f0c756ccae821420ac080dfb8811ccde45df8ac834c25297df1851d24ae6485d5730278403cfe975760501ef96628a278274638401fe9b2a5aa772e00093d954c2ab588104566156152e1e745f9ad1a4ae1e0ccd5f7d8946ce299c0d0a5bcd0502d8d5445d20c60959654be392e04b4135090dff2a751a2995e1e2b877d3f67e2d326a9a445f194979a79db46b26093edb9743a404e10cb4b27750649504a410be329e8a5fff023ac23234e7be78f88495ddb82850230f770193cc73e49a12d228df276198fa6131d2ed04405de6a33a4a419306e5941c91cbd9572b63e15847cb8fcfdd4e80de393c57a667dca6324a25a5
+g: 648a2773d52552c96fed01fd63c067ba8ccf6c3dd5b877ec5764fbc5f81286bc7dad25a56088dc85c596136f22d683b9155df8e459a820c98e4701b3e3a5793e3f36769b60dbcb119c2e64c7fb1622c32db9b36d65f6d5d5a4ff86461871f8c9a1eec9b0f7eeccb82e0e54b8e0fb6d304ee75da9943ae61bb1bfadf7c0df2fd26093f0f3d7b135f4908bb924e27c9d87594dc4730aeb058bc65e317f92d61f00fe31ea654db39f0da772abb7e0578975762e094234c612c64a97cbdbc5685d108da7cad60134142d3565d83b04569972e4e3a961f152f25f33f623ceb4435d6492491a4330cbde0f40958a69ea1aa0ed4ef88bfc755fc67175ad804574e54654
+h: e0
+m: 7541d261a1c5f1cbd7df6bd1872a3ac98caf95669f8aaaf3d386874c0cfb173b63b283d8da85119b7ad0a237e3b2b55d4290703ee1b4e4d03d504bba102beda23c
+p: ad3865b9c1c13b84ef773f3b8d4eefc1ca5c3630b8ae3a496cee26ab78b60c0915483ce2aa2bcefe947ba38b4daea877ad9e1e36e258555e5477157f7005eadcc69da336b15e032a608caf4c6e81c86ab6d892060d809eeec34a364faa3fc14f3815d2d19684f3ece3739ec25d501bcb8e80d060d99b4a59f187d9980a02bc00d797d14a8653ac8f02364e04a7c270bb818122257a7bf949ed80aa4fa60cc881192721358b2260d6302e49003a57d24ded33c68577deeca73ef7437ef1c30c0a4e87b66dc9e59abbab783ee735f79439a115727c40291fc622cd2f4adbae5dbb8606edb1a94a96d489a8853d07714fd77908dc4cda17e746a14d501de96f92af
+q: dbb867dc0e56aa48b4dd1ab567d1457f5bc6e5ff8b838c9dad218509
+r: 2889263370b7cbdbc933144e05852c121f62361f156f23124d1dfc2a
+s: 28e2c3145bcd24e52d05574ac28bfcc77f856b803eda5b455079bf28
+x: 9484ee47d91746cd355e6ccdd0aabb18754a180734724b80d9ad82f5
+y: 21bb8b5cf74ee51b1b8720d9b90976b3f07a7daf30b8b62dcb1698851410a69b0ed041fa73e8dde17ad50ef8acd3459aad405266116ae555cea1c9491333a89bb346b59fb4c64b1d04f560074b1757e81c91c06b209bbb1040b00302e65fdfe23e81937d20424a795c2b392784ac4f7e7000de81f4e0e52ea2e825302e95872d28a01c173c4564678fc84634dddd38496f2fc3e41b667401563d2484460929f5065fa777bec4e8e22f8543eba9efbef61b695eb35b9450d309f7f203c0e1150a2a1a655ca6278d3afc61e564ca6a96bb50ca17122420475bc2bb2ec164c5a045f712dccde83311bd4bcf0616977e6f0c51e86e87e467c8d36ae3259c67be9d4d
+g: 60b67122ad17ce091d5d8bb2ad235b7de0f18c254d1de9d472384f7551a37f84c2b7299c6853a7545642f397fb99a70bbc6808f0d3afd626cc578ef69b46c5a169432fea6eaeb7bc60d32f9ada1d7145e6124059d55e2efcb72632ccd4142bf2b3c58ea2ed4cf76c61e9d57fdfb326f0d0cdfdf3d6781d3b7e17abb74ccf746845118f7086246c49eac4df3a6494af575d933d711283db0e0c13cdc7b53cdc8def3515e6add56a0cc1e4ed2e87eaf8622f7f2664a24afb3cda91f2b4cb1b185876327606a63cb5db6c65622fc7cd66e923d12b7d9bc1c0fcf7d9c52682f058e285aee044f7963e5a769339b09b42aef9c423f8dcae80be913d6075e64d002edf
+h: e0
+m: 1de638e1f3ef07a62af620f5555ab7b158a5ebc03a544c45107352cd5bcdf1180099ed6b3057f37eef61fc0756929f50d85dcbcab8ea10d23d967a4bc62ad7d057e23a708c8cc4b1e94cbd5599d8ac1547c67df0e166e949f2409e14a830948b96df1fd771db5c1bf4e03c3559dd54639b9be038c74fa2878b2bd127dcedc6af650efc5dfc9ac59db78e773d9277993abd492be923f25dc497ddbec7d44af961fc0210d7fdd7c4653a98215060448cbf65eca3b7c41494fac12a52e59cc75113fb9cee3c2da34b97c58a
+p: 80802c75612fdff5c7e6517745ae3df2b7dc7ed90ab17f082f1ce5882163172415d1c710815bbd4ad2f421085d75ce7d1b8e8ace04c7d96c6f4de5f577289ae8f2ea2a9149a5584f12d95648a7c287e8bf7d97706a0cd9c6f6221a78fece78654556efcbf90c9b81a68d4f2b53a6873af004a4f4e658bc3f9af19a148cd21f740662b017e0cc598d39ccdad7eb8630eb8d6869b08a017ea590620e15131569e914fed8da61a6ff0d1d3e2af83a3d58cf208be622f501086022e5a1c4efe959bf4831cfdc232bc477420627e98a4a8b2e69523520a902990bd1e45bddaeb8346c1777238643ba64d36f38ac503b15b5fa011b69d1dbfc373afab6713d5adde815
+q: bd3c358a1baec377bbb2b3c5424da2a080a56d830cb7e14636e781a3
+r: 6140321c6142d643aaade303e20e70c11cb44903d913c3506b3130bf
+s: 9e60de19a7d536aee5175005151e570b7613c7605460471f260b6130
+x: 22e4fe758e368c9997f3f380c9975eeab46c68dce9ded344a51b873f
+y: 671bf8bdd551ceab91cdce1518d2d44410f9ef481adcfd9101156d376c3df6079de85ee60eb80b342d25c4b12567e6d9c46c021beef0a7a9f4deb2ae101c1f39a778afca988fd49bb699b13720be5d429ccbe3682babfd18e4760e556e3e75313fb138e745d3f4a4c7426e2de0fdf40c72b446f4dbb8b2d9afd04a2707387ab505d216cb5d39275eb792b33dc419df1531506fa5f54a4517272e71ce6aeb56abc8d4d7b2f4d112b312520ac97f1a363ea7eba53e6b3df727f728d8a88d960622d6404da9007d3c07483e14c1b92ae35586e665bbe271600ce061f41174a904026bd6b140fbd952438791b14f75b8ec643785167c078640c43806909d70a72884
+g: 257746e903ac167732fb4fbe682b42113f566742883e6893e7efbc73aafc7cffb044f4fd4b185268a0f24715bd205655c21af803ba91d09cf76e9944fcfe4721f90656385e905216b0a5bf9eb634f0096854bd6fa1a507241e82836afd4fb354c53f312e794845ffae2392179a7b9926fd5e3b5a152223a65767d549bed22acc0947cd43c7de7ba13f422d9ccd4a6c0e58529585cd0cbc2ef6d11cab106dcb6268774251c860e3af2eb9f6b0e68e28632d430feeada26ed542ab095068de7ee8476d390e6634b4c4074004676005950e2b1d1ea26440842199ce62ca03e392fb12b43fd90acb8e165216c633e04ff16d64410cb734d2845de8e039759b42fe8
+h: 180
+m: 6d826b53c55c421336a7948c72c0eca395412b4eacd1326427adb6f868c58e92984a6ff8f3121f27200b24053347c582b8649f8683f05380a181d9370e60bd008daf8433df95259491b11465bae397836094229d1665bc5e855b151023a4825b4252f0ea569e39e7d06c09a6bb64c8be98
+p: b0786459b659a2e86263cd817b6733177e95a7ab9f1efbeb2414320ec1391486447c287d55789fdcbc07a65fd8302f6966a681eb7a0727814dcf3bbb83ecf62b5f156dc413f52e90331e235bbda51653e293d1b26a9b14ccf581e2711ca4d98edbde20f9ff6086572075b4a60b44448105e1a569e061fa23ae7a34776ebc25daeccefc72232b53afecd59878f0903f6e20c25355b792222f27ce8376cf104777bca7ea9e226984ebec71fbbcc6b309fe77dc877a1a826bf8cd95621c03bf8fafc555fb7476f0610cec8ab7c6ff4b2f547efda139cbd0e1906f6da018beec9b7c1a03dde981cdb98d85ade99f01a7e3313444f642d872878be4a3ad361077812d
+q: ffaab7a8245bac019458c9351bf5248df74c08219da802e05d6aa2dd
+r: a489cb7f840fc909c01e2f5dbf56dd71bf8b80ac6bf445a50faa52
+s: 5835cfe67ef6a3b7062e6b0293b2e38919a61002ae75fb0ddf321538
+x: 6eff90edffba20cdd1b6d3f5f2b833befe71bd6246269b6e2c24b27a
+y: 5fdaa398ab81276dcf1594de8ffdc295f1c00cb65b7c721da46e4ef17fad82039acea821701b4c1cb86b7b20794fb13c1d35e5e792433ea1795ed3163e59732ab090f6a3f87e00f63d708e4d8d2bae1bcc55b72023d3545883b92d6a527375b2fd265a895ad96f856b50ba0b403a1fefc0de4954dc05e8896ded337397a8fe0eef1934025f9a005e0529ba64d7efde86ce5a5a7eeafde765ef5030e536ae9ab7a8c62b6111c598d6e82e23159a356a09f15fc28a4f4f5580e89e6fa00cf02009c9d886fa28d629a1efd2d4563d3f85b2f8fcc0db8b6f5487354e54f85367ecffeb005863a6d12bb980fe2a96737359f3f52ac9de679a9122ae7987895499e26b
+g: bf1eb1613ea3cb694ab4c777c5f3805bed7a07bb0565f822ad4366b3d0731173349f80eaf4afd7ecde01cdb7337d35695a981959b91aab179fa5b50f16d19398ec3e41010c573706ad59b6f98d32f9ec92fa159ad1fe133f54e3174ddfc8f2b855f9bbe196933c3c8b7b9248959c3e351858da0c68dc7aec49703d4ee6693fbfd137b254509e78b4838c1570b322fe3618354d884f23e79898512576265fb270431e73213dafc3379ef004ddff329843afa901cc7a22ac8335fc8b1276b9f1441af5d292586ba2b4a28ce753b8d736eb781a30ec90f12e38505171182c05aca8f1ab4dab36314374c65e2afe79f674d3595ee54cefbd14be4b8c26421e2c65cd
+h: 100
+m: d3ea008623e60e26e7197b1d8165d5438a94fda258714eaa86d9344e05292915e7e4a1c58eee14d44b0d102e723ccb1cd3db82aff212dcb29a370f6870f78de4efe55f6de587518e9258f0f61403bb17082aff9a71fb39315df37d5ff104245350bd8c4e4358b933eb7b0efe21a3a2ea2e4f0d60f40ba300041e15d7bba78fde52c9bbdb0a225ce74754afd573c1689366f0e96edabe589fa6496fca9c16a0379b656dbf7fa6aee3a0999d10cfb03a824cf5ef30374a4fd15fdaa40155fe924be99ba3ea58abf965226e6344d8cb82b7fa3ed9b1d494197abe3d081e0f6d4ecf918d84b975be8a2e
+p: cf64b03f0e616eaf7a1b4b7e0a42aa5613455aa157e6fa3b7939f372ebbece8d6b6654423215f7641cd25eaf3453dbc2c02cde8571ab362e425824e6cb6e5c78cbc2327a2e8b4c22fad6766ce426ad18b347c2b064fe32c5e77f75b98f784baac22b6274865a1bcc236190a60d3d5c7d4e3085a3ebf581a31c2fca597494029ad04c17f7ea4fa318518f3b104d1ace6fbe0db2a17cbacb9e8cd69d09bff203d7fd4d19f3095a456019d0346f4aa4df7e29e7cfa346b7c52929bbd7ba89cad7bb1cf194679acf5458cb60e8075b0499e954d45a8e9cc5bbeccd548c95a9a206ebacd885c65410d273a69aa7f4997cde52c100a8c4e7816da658926ce83848993d
+q: 898ba0a00e5b2fbc8522a895cb2de4a1d7d7de2aa3662273c0fbb183
+r: 41ca6a3f0dd8b7d2ac8c57203bc4e99e3265f8b5f5c0aabee9cf0175
+s: 4fe9fde8350388693d8b2e76903858c99403e2adb127023d6e1197cf
+x: 3801f472df984ab311fcf040a513eb5d816379f395ef92e18ffb7a5e
+y: 68c159a9384c7a1eade817db453d98290a38e2c416f83cd1b6ad75878917def3db8a7ce910acfcf644becb2484df9342f8c86027153dc20b52b412c0d4460ffe62101f02c1c60fa69469bf29180d1219a79886c942f6600ba011894e90e46a88fca3e11129326594b593f79e74969af1c22929a71088da802488103c3e2395c8c835f9991f196fdf4017e8d495ce014b105e3d1670c0b3d91891ef4cb8c26a7b1c2c86672a2d99f052facebf4d2105f779dd0185b7f1cc426747f866a075da52f8b9e1f5cc1f06b93647cc40e355e00b858ade53b20dfe72220e10e2a3376d282302ffac5094d39e94b5918a980203d88dcae27ab5a45cc92fe654408c2c4751
+g: 1584727688781178f6aecbcd3ddefe19aee49e26340c7be928ffdfe1e9f79608cb57fe10cd67a98e8db554a22386e4fadd3a379950d31933b904cea4e29409c9f0e4619e0408447d5d7d60bb5c6d5819557bfa5763bbac7517e915a0da32857664eaa1f60a008db2e84d35376da11f40e339c2fd05d1bcd17c8051e6849425e91058ad0f190b9b12e90b1cca789b4e4cc22ea7862464d3f92f9c423bf0d41d34a9438fa39f1f70db772b33aab0b13e4ff0f565a2ea5f0da1537bbb8ff909ff32e2ec4a97dcfbfe34dac266340804bea72de4555563144f053b0016e62e2360a9075d7eb34f7879149c3d579dd7dcc6d3096373a0f8649d6587efe291c73aea77
+h: 200
+m: 771c0510c70a779f9f57f2145abc7eb483f86404715b669ed508e36238597c86c12d0ce25b092b665ea070f5b9413450f381e95ea641a6d746702d7bb893c85e1a92e22a58f6f04e40f3c251f0f515bcf212afdda3af7539c2c5add40108407fd74bf0ef4ea9f3fd43a6c33d6b9fbadf3cff81d59736aafa6dc4999bf29c43773ad1ba47b941b55f874184f1eccb01e23f02259b1af1b97ee49ceca5ddccee07406044150ee76d171c8d1883a9a9bc4a7b039412fce8bc1d782ac2ef490c294db35262d24ef3db78fd89276f8d8987bacc64edd0327cbbb4d3e9
+p: a1749ab6c0bef4c46217232c9712e90d76dbeaf4818ac7e138bff366686e22194bc3993548968bdef892a34902719c868cbe9037ffd4acc74524fa8a5857ba9d0238fd3a2c7a7073048bb53d3e8455c4bc556b981486b2a5dcad4f2006d00ac992e37f677f9e7b660681a9572e3bbdce0d68a9577f1296e1c60b070a567e99b432240199565cccb8191982758814e3777e5db0b88cae82f8a1ed05ae5514bd7e68f47cebf4e38e7c80bfe5debded1bff420a5569c42b4ef02101da5623d16ace95fca025ea0ee7c282207dec498225d0cd27ff86b73cb2757efba58de340d4d3fca8bab627c3d6eea7813871305ac96247e6576538ac655f54d8daef40076b9d
+q: 98b9b8d5d699eb67863acf54dc585515f8556c4c8e797aa80ca29981
+r: 59f8d7276262dd6be4fa772987a7354f403290d5b5f54d8ee445ec91
+s: 716b0946762416682e47c7fb8e66684a5e41b53ed3c5e1d179379ee4
+x: 278bcfb6ebabcf5fdb4d7ca2d34f747dd772b0c39b985b7c89b387af
+y: 3dc886e8c4367c7d55b8b2fc075ca954991ed69e11ecbfffc5cc1b207e1ec2d316fa9645603cf1078f8cf369d5743fe96cb88a6d119ea2a7e647c84881d1642abe540b65d6f5ec3903c21692f069a01fb4ee450f7d173dd2bc5b264e29930bdfdf235b2f7b998aec6e0e8840f112049ace527271da785ba51dd9d02e7710696df12709db35caf35ccaf8c7deedfbdb9752b82648183d81569a896f45ab9d7dcac55927df6df34c8a222feaf0729dce21a748abfbbcf8b7d176510b9871ba9906ce3c729aacbc392031c8cbf346b9e473e1fffd1f811ff572896f02039b143f04a148400d680ab8567be2ca1f0d046557996f4a413f19b2b8b12498d6bd792117
+g: 811e541eeddd0f9fd4e29431757e4b78f8d96365e6643b5642f5e0c6930ab60d590f9f7af065d12a62fca4ed8c92fac2c8d2de0c4ef8e8fb2aa56d2b115bb45a34d468353e0d3a29a0d46e40f4ecccee11e7164dc4751bbfe371b17e0a5ddbee7676ebf505f82c39d89f78d2140d23a8abe92d37031e33b1776d807c4fdd5538ffa86dc8433cd91683eaa744315adc402454f95f25b6df9b2443dd7e39b365a8377c17d5d51e2f3b62129b221db9c9bc75ae212636923d92a412b8c30e91d570fe041a76d49d959772ab952d1eb5642b12738ea05377c297ab221e9444bb35e8ee4c706de3db285bcbba2e67bb8a239bf3c129497c46b00ad44bab011e5a94e4
+h: 180
+m: b21199eed176784bbdc0f0003cf7376e8b502fbad79d16a2
+p: cc89f83c9d4b7572be0956a4f303b47d9d6b1456913b7fa362c7b7956080df35b1302099b2a00ef04a07383346c8c80cd6a6593a546ebbbc01791eda0e270185132043dd06a3c5826f147ba784005e4965bc3185273a69f9ecc4a9ed06fba59f61145131f7b206c9eadb000e7070c10472fee16c8d0596d68894355d4891888c578505835bce44ef9b5c679bb5f9ec4f7345037683cc3b32dae9b0504d37125fe9fbf8a8860fdb92645c644ff0b36298e3b3c2e44ed2fd5f4c2b60f7c50029285e8033be43c270739ec466ebcafd1a69cfabeb5f8348d9ceb1aa73934eb867645ad4196f78faa654ed35908594e9f56d658c22f512d599801927da6f156188ff
+q: 9dff5ff90a7103cd59d3edaf681f99f65204e7d5714ec9fad7c414a3
+r: 7cc4e937ee082f6f5a7239640af805b20199f67835964a6e1f27e8ad
+s: 6a7941a5844414d34427879e8d90cfab84a06ac93c731d139d6b0b8
+x: 67a20f4ffaa369d2e24eb2ba879a8481c8cfc18c1cfbba8b77e615a7
+y: 6c5ca61e32f9e9603ee29c10534e1c827811311e2b062a689649b94179816baf043aed44cc095ca770611c580cc6f339a6361ded866503db710ea058ef8ca4e47ff90bec3e71a77d679580e9279c553a9c12cc9b06d74f94e2146fd70cdfa4da0e5e528743d0e0e3606a267fbd4ef633c8c13637ad34a5b7cc6d0d385d305703d74bf594991a399e02b638b7937d8b7a599b8cc72635ea40f199c5a6528cfeef418a0ac1d9a34292d5a51eff8a08abdc56571f9e121a801e19ef7f7b8c31ca74faba06c56d49ae8d1a21702f7ee36cea85f5adfb62ff8c5e3396c20eceb0e31149c37abfcb4445443cf43c92267188ab0f9db08c7c272d93709905760db6b2e1
+g: 4833bdf57b69b6bf9abcad681342406937cebf732e1daaef3d34f07396c6aea9079e057744690410aff26d6c963e9760e50b11961a9450a84e9fbf56bea18321c8c699085aee436760c2faffefd03657242674c4ea464b06c035ef64577227ec72d52f152c877e61ab8159bfa3c12fde85f7c4ea31f610fd383b55b3ba8f193120d363346d84ba5fd177afb4c4eb7235afaff31b94d69cc336924b1cc61e39dd41d422d533a4adcc79054eb22aebe4d633ad5da2a01860a97bba867b783c5793b7f2924247da18b2033dd049123fd2941e03658fdb7bba94bea127a3e8c66b6cf25c711949892527df17171acc57c357b48939e7a0c44702942ad5d552999f96
+h: e0
+m: 37fa3721338c7ad4344aac8dc50187f92278f7631187de1bae981c34c09c53ca10ea23a2f92644012311c46bd8403f008aa02fa2bede0fb35d182ca632d29d6ff64fea595ef35054ea8d915964e7f89c37416b85f0d64723a6e1df5c39314ba6999ef80288c95569f27072d82e9f520754fb55e4a7d1af2ba2addbeb1010570a2ef39d722b4959c88f3e3f79f63fce6689184957d35f8f80ec078a92a5157f70c16d7f37edfc26f0ad824bc13e8ade98ab909a1e087199e2d0aa0a15d0cea70b413cb6c61887acee1a51c358b4bcaf60d2ad4dbf7be97d422eb375b27ec3e28a8e0f8e38
+p: d415a669ee6551d331b12a62ba7748b6d6996a358ec511b70c9525c22a58a3adb38be871f70b4115f709c9c62ed7fced65497344d05705cfe45883a785494dfac0f5223540088f7229234a6182a4fda917b19145b029f4230ac30a3bca3fd144076c42e04bfbc8c57944d693b2a17a30bf9edde05ceb1be41b0abc52ddc9c72320acfa95ba883741df186afbe10db865dd0ad540ecfc1e654fc9816598c8b29fdb5d1aafff6fe178db3aba9d5b850d0238a3262f4d001395c96db92379e76daf089444e575015946f62656738f1231812cd756fd7a92db4dcad7414dc176231a895eac194e8e27dfe895d501e32cf87a9b88af7ed0f900712a337c2af6eaf837
+q: 87a2a55e0d1c59fccb6f5073c594356370b9b8ad619bb8d079e16077
+r: 581422c06b69b5548061b419492ef80d659bcc2ec17b064ca7fb6fa5
+s: 4d5efec20f7ac1b7d192ddce0f2ee79c9626f046835f6db106ee2911
+x: 4fe21fc25a1e963df906747e4fc0313ed585d5f5d23c5af81e68a44b
+y: acca364adf286020dea6c75bf542488ef57060db16a194307063ac7d96e24ef2d46fd678429f8b9ba4bcf3052c78a4494a959c82bffa2b3784a62198463fa1785243ea8723839b1a3b3952bc8b442e1eb7440fb421b3bc5100f38406a11eb6b67112bed18bb9ad1f2524af3606d74f9f763a9374a67a5f2f9399cdc8c02e0033ba5d3cb6a91be7eff7f13ed9fb1cb5486da97ea4f26f242695403512f77b07d0ecd9333b6c0e923722cf3934b014ad55bf2d50ef836110841d38c4ffc8fe2f47a073152a7b6f764be4556982c2bc1d058f7a6838a72377fd26d02d76178be863f60b4039deacf3cc12672dece4d26bc9c9ad63b433ad6c092471a8156b09b9bb
+g: 267bffdd72e9581c333dcbfbf1b6f60e89b495f79ede81e8584e1175b84c6e87e1e0b904ebebdaea4c9916557a652c44ee683ef3d8e984c9fb6b7c5ecef3c4121fc32c68d5595035d2b9e5ea942a19ab019151e551813229dd4fc281b127629d53a811993e0e56af8d9032432aabac547549dd7f1ed8606310d84ea190d81920f06e2b1a2b4bf41858f73864f67bbc69ae4e25bbf15159043a2d85192c5c85673e0c726ada0349692ac1b47b6619be492c5f4cc1f5731aaa6c2b8a6ee0b2172218df603c4e5e1aa274266fe64f26fbaf252ab1b7bdbd43c4660375fe253c1ac2dab8006d77c73bfb553723576399d160aba9a473b4eb8c408261b21a8427eb41
+h: 180
+m: 6b1c237a16d62320227ba897a69e0730f28d1e7914749719f48d8a83c84fc6733219
+p: a1b6ed918a8285a65c44c5bd4e435cf198a43cb74052a98e124ea1e7a1f1ecbfa69cc7827796063a601e33fda97916f39e69a051047db9b88b21bbf5bc88cd79cdfdbe862a372ed0309c8f4ff5b72d66fd28539aecbaba9a59e3215ed26e1bb7de440118832c553dae9ebeda50bcec677d10f6ba7051eb3978390673c9aca8bfaaf9fbe50900598302e8be3bc63f577417243b2c834e50ea46a693d75c4febdd409675f4163354c139006c675aaecb9949739b4d3f41b1059838542c1a5fb04785d9f90466bae5b70112082ef0640218ac892ebafaa3124c279d1e89eb3b5c599b5ad770751da1c00a7173313ce38f0ae0af5dc8f7541da0aeb365b7a9a6b71b
+q: 8939cf3ce028a618dd8757132a58602d08e267b1118ebb46156840cf
+r: 689e94a9a3990c214df888513170ca0a30371a448c44fed80254e9cd
+s: 3dd683bc3e102247d6889074d12599de3101a78a9ee806db2258becd
+x: 581bae3ef6b1d9cd92dbbf9f37ce560af5a440d1596a3a2432a792e2
+y: 74f2f4b654f483b843ae41ae78fe5b69e48fe8bc289fae6917e063588ecb9e1f2d0324aafe2a761c826522ff7505401690d1b016a366bdd9039d359b2a83830a80eac338a4f67c1c5136c4d3c46829fcc1f2c948427affe7b28c3368be6dc31f8780c31600f8e9ef6b2467171e9bf8fd00f1711e04b19c394d723a7933895c252a2718c5c11d409b8f40b28b39a0015198a49c09e287f4dc4393d78ececcef55019236cfc3e9eaa460f9c89911eb133b752e0f3f996abb80f79c6be85044350797a7755f45bf82196284ce32b9544a286fea7932be52143c15bdace01a3da409a8b85b11c97d0c0d9f4f9caa822a1a2c2c89b4680aba6a4acd65acff9eb924ff
+g: c4556043144dcc79548928969f15ae1eceb171e7f96dee0a0a41627d1573e3d74ffd99af66fd8f6a5347e00a5332353426bfbe7bab37a387331c44047890af2a21228e5c00128fef7354049f7173b862ccaa0041639252a66ca3eb19914929d96131b90386100939b99493142c8dfb2cb35dd9d166064fce1b1b91f639bd8510eaf6f509a0e2e96cce642e28231dec781f2ff3789882ad869b787b4d765cab47a90d5d451dfe8fcdeb9419b3e0c4adfa5c8aa02bc622314f43469140ffe5a04df7d080a5042b82af1b559228d39ee74a72fa25df2a200607b8e3f79bfe53997e3d98714f4107b73deacb04adf4aedcaccf786238ae6a5e39e5a0adb1bab3dafd
+h: 100
+m: 82ad6eb15e872132c38a9f5e7baab68c2b117ee1651a42048d431b461afc6ab2efbf0540d6b9de8d7960fe48d3bf137143e5758f1e78b3f669bc1a3240719b54645db694f59161202c642cf06f89af5dbe79bef1070837ed6c0c496df1604d8605480c47a6a6ccbe47a74f8cdfbde831f694fab676e29d26a2f820f2206f55a3e2c8f23c91ff4b525955bb6939e40a003f4c9cddd75e558d94cefdacf7a10bf3d3e8257484bbe3b258cc6ab4b1a49df95ff16b33aab5f59e8e7c163c7ec938f3a4a7861913171b5c5169c62b994ef36bb8505b70b2e1ffc06273856f7f1e80775b06a45698077cd8e6128eabfa2f67b747b3a01b
+p: d1747c3236717b4915a6f5e63c42576a69f5975d41ebd0421b23f95b004ee9231848fc086703305c19108f3d580ad4f1a8e42052a6e93e5495f873cdaea274eb54b8960d7dc28b56b68184ef2418dfb0c84b0f56d4ff797f5c24470cde44037b74c976854d931069a9d400acf8c54495de171485b013e94ab5721c7d5b8989f98acc26f71cc622741db67b9929667f75235ad8988950dca0a34eb2465c64dd8187d6755f138f7104a220fdb47085beeb8561e5149676ef398e1d6e5d6336175e4ccb1b617319af384b0b068acf6cea64aeb0e112095b98271f612ed765c3d03dbb924b1dc7bdc117a1b26f435f95cf9acda153113a13e8c3fa78c5db9563e95d
+q: 93bf777b59d7c7814b218674b817de2c64ab448d6696928fca1a4a61
+r: 250da6ef1b17e7bb480becbae472a0c626d8621bbb8d3662e4ce2cd6
+s: 5f2eeec78d768d1e757a5eaf1d8e01d7455e7d380555599d20dbe85b
+x: 669b019864e18ac1435d6be8a3cd19b421bc2a122b29149ae098497b
+y: bdccd40964ba1cf8d7e5bf23a61d6a5e789bc3b4263912303f5c794cd9b171e662474293b46a0ca8a6d77752123466a2d5058efb517a5b85578da9909be6f9d578127de4b43bd30c377bb68099a2cc159c2c2d4ba2cc1204e8bdbcf56851148f489438cee580c72071daa9e1b3894424af23733e13280839ef2cff633db4a92b673334640513c0ee5b6dde31848c9aa7a713bd1f93ae12fbe53e9cafab731d2edc95b3923209ba20512e9afabdd4895eedf2c3dd9250cbc1a3829a7b8c346e2db13b10e5f4cd88753fd4f462148b195d98cfdce73d1495f7a4aa0e34c86e89fd4cc59618e5c0619ae4bff3c70823b92b65dc234fd39fb8abd6748e5e134fd75e
+g: 25e417d0e8a928027b7d1fb57842d606fa286c585ce1328c7ce0d0df3dd92e3eb76acb2077adb0b02946da2b76fee3ba8a26895e044edfc7ebd03cd684ee2989dcc1a3b30374e4cefa6f37484a9c9bd39e687aebbb7978df2e75c9830eb45bfa3e10c9bd7b22ec3a8709c84bdd272d77f2208be5f1c0aa248e5af43e26041826bd4601dfa0dd47417b6771bd7036a346048421f4553be135f1458e8fe377188f9b497561646aba53548da8d6289108809b7b348ed23562e0efcb5d0c4cf456c116ddc89cf59965cc1a4e3b9e33a23e053c028d90ba34539ef5ea3ca11ed78a8cb1edd710d043fdf5780b0f19dfc7c41c17c735725cd94110c270f3c3ac6035f9
+h: e0
+m: 59d1dcc21a5d90ff2dd706e97ed42e03b9787a27418cd4a8974545b9d8b354874f5d681e6c66a6d6b9970c860aa8957c0bd8dcbd4fe32c42e6e09fb3c04acb08495ae611387645b3bd0d22f947257a8a7aed723608d58254b291bfcee26e2289d5d7b24532904e77f2fa26911ce576a4b28956efd1c2d172787d7a4221d91e753813bdcb37d0fa67cd8e7d38387d7c1a0cf69b3da2cb1edd38907297803476ddafc85c8e6cce452a62e890b9ffbc1bee643abdfbe4dc192b0be19e23c6801e45b1e7
+p: bb7954df68f66ba149cfae385fdf32a273b05913aa879be1f89e9ec700f378ec72a5411866c2eb2edad4700ecc77223842c0d4af37eb1f8206bfa1df761baac9714a54f38468b41c3a333bb174820d54245659f0e613c1f43c922d06aec24844b3a3ff5251994e2e9e90f37e0c64bb60d74a9c42812710cd7c62b850a98e9a5b887266e4afdc0d6c4f65887719730c2b7790311562a9a7c1a9fe1d64959a457e669630cd7e49f9aef709934f496a060114eb7d5a004e566fee8609f560137733cde5b2b6c85a5aef613404838d70087d97a2184975abae8760eb68959ac61e4c003214b63f3a0e89606b8119cf0a29b3bf16080e528e3e1384e87615365a088f
+q: 958e8b68d86bba3500fc209cbac79a459c19c350601d80a9774b7ab7
+r: 945b8cf9de2aba9427c74d7fc4411a03781bba73db3a1cc149a590b5
+s: 91f0f0acc8ec2963071669e22256f03c8192b947e47fd0a8402bca10
+x: 87aefcacc712b1c0764e9a4dab6cd997252f4b120061379627a207db
+y: 460e197f316d78967d94172bfec9d50ab14d12aa663997c32a08ac62d80885e2623660d390468c12036a31beb7f0f451728a28017b1841fff0a0644415c2b8b7d61256657d3dd6d59821ff996cca41cd419a3221047a37bd8648d352e0fdcdf6239d2c0b091b4382b8aa21a7665d228d11cf846123d235fa5492206c06e3e2f31f51cc72925d2ab030e6b55ef1b07520f9a25ec94f3157b2d3d637d5c257fa97a62459bdeeb9eb30edfcc1f7afe204c5baae17158e0672c484015ce86d27fd903ce91d0e37bad3a73c34dfb0fd4a0567a5b2e84b8741cdb4a7e5db118339cccd87a203cff875983638dc51f864f8cf33174afec59ef893d814eb7185d690935a
+g: 1fd2c90c4805186226c6be779c58b4a1f2b10495a94ec48d8c3e9b5686fecbeb19b50aaea65ef0602b293a017d9a1000c0fe75b74adeb6015c03ba2bdb6f2a642c75a1e312f3567df169e84d837c6bd5e176b5999bef0a0da4102892c7ff128947fbf503822052bf3f80920591a0324be830630132d7d5d7c5b7de8471655c6595b2deb45a93490180b42dafc079664fcfcca29e651d828381e7848a55ba0c5307da00883d8515e88e4998f49ef5a3294e73744afd89988801de1c6776d1de7326f39a9e9c808b813f6507b7de3ae1b75e3098c61fdfb3ac3eb539d00f88976ad65f0533b978c3c24a866de86d2773e875a931667a3b56f90d563e680c33010
+h: 180
+m: 1391d8e30f6a5c5857ed117a3e2468a2a0101e358d765fbc24023eb01eb7861653cd
+p: 8a9d5b34a9c009889820c3de356a6570379a908806fc6923e9caca7a0dd9a536dbabcb8771535fba173f554b95c32ba506ffa915d74b3c1a3eb26b71e69416782be569f711f83aa4525a7b9a4e4a42e8608940224659ca88046f31e4c10f15b87195e160743a0b3226194e6e472575dfa198e16b2d4e3fd780afde56a536211c7ac245d2da89b0a2289116823676eb63d06119f6c1de0fecd11d6fc51f5f84371e6adb3963fc49884de3f2fd73e0a7fdc27880b97af20a950df6082af7e99f709feb3690021ce33d6723158921f2b64f995c286f25f7df4c60917eddcbb5ad000f7d3bc3107cb13b16cb578e4411440685e9087f5e88c577c1280106f452a1a5
+q: eb3156fa9b703b4fc81a88d73b8b1027e5aa190b4e027bee5b4bcf5f
+r: 191023b3891a99f9be78f157609dda119bef122b0d13f5bd593c8d8b
+s: 98bb266b279f35abd8c48b7bea8391c9c3edb12cf85bb88b14013ca3
+x: 5dc96a783ee46e6478793a2a03fcd71d46b4c2c1a9842978bc4db39c
+y: 4509874fb9ec7e6207a3ba2f40533f59a8cb594f77a200ddf2b8c6ce43b476996898072eb4d0e403be0a4cefcedcd3dbd2d3b6343b26819fd3b08c28253069e09f97253fdd8094555ddc94d375c84b905a960b02b6dfc71d455bcf3820bab25d8d52c83f287510e5cfd0cd29ced2efd9546509c17f2cd5a258afbfe59e2a2569490d6879e4c968224dc072603a7255224f910d9d8b72cb6c95a0466f1050b2796d346089335cb89e0222f9c4525b4b10467397c8fb073dc3fa05856ec9e196d0c40019320ac49d9ca5daee371d674e43f8ad2a23f213bb4fb01d84afb8934c4bc251907003f30636b73ab9fc32850cd9b8547db930aba9462cc20fded6e89364
+g: 83c70f14c85ab511142edcbb17593c8b26bf2ff126f6e4d215963ed10b05a014bc8da277fb3f9412940e9fcc8f8eb5a09f2f017d98c7d7f5a08359bd0480716fb0157109d33d810fd0d5e94c7721739d2bad7e155df9452911becbebbe42b3202182de415fc761fb3b30a2f929d0818626ad6a83473c44c832e5abd3efac4cc1afe0a1364322f2a07d6f3b0603e8480be9f5dd974f8231cc302f2d27646b552684773b16ac69b7fb255200574a74b7d64819aeff7b7c8c7f1dffdbf4078e445b12bc090abf5aecf83b4b16ae3823b808214814f91fad1daaf94647d09ad97061bec0af07b7189b6fb386e7611e73443f38027080b769a7118d31fa39bceea854
+h: 100
+m: ed7952cd586d36447d66c12646aaefe45c7684fb4c1c2ef92a250023c6fc36ee8d4c0615a2baf4499809e89c43d3e630e52feaecd1e33d0ce1ee440c4a9b8847f0cf39b0b45817713d7e80bcc2f95a2c12af79a205b1f07da0e9c314afe1694ac3c858a5696e75d09042a260e96d26f3e51296c68d1bf9e569aa4b468572e95ee7363f5e52c618bbb0f66286058e1207bbfc510e35b536a5c26dd6735a04166bc9d08c0d06fa97b4b8b101218b10e01832cc07d19c7d372ccca8d8cc7a6de55bf9032eac200b7deb1edc1867d65a8b987410e73b5abab0394ac1fdc93a3e4f90396c3df8ee83e22eafd110
+p: b5996f897bd23f28306a1ebc72a3b226d3405484962b125732eb3af659aef385e260ac5db1f15b4e574bd3a6920fccab6e2a3a330a65f29254ff3cc7774867a9c66a7eb47140900e6864e54a35eaae78badb17eba89732148d78715ca0c13ea9addaac257c761c304e5d09d01aea14ae3beaaae8aacd8102fd932f3ad35161b7dedc20e1deca727d4496deff89a92e72d508e310c1937878ec4677ca610ba56d8a037524c428463dd7f777bb76e5b711d4fd4aded7625afbaa1dc1c2e29b1a574c3a07b2b208b93d5dff2e1960e7c9208e03af5bfff7a592c4b6e56bb041f23f1cbfeea2e39d155beb737a11468b52fb05639b409859d887658b3626c6c63361
+q: d9aa50d49312085f55f86e24e8ef83b8398f0a23cf46aa508534243d
+r: 631acca69f50f898828e9e4e97f69c07f501260db4e3651a90302c09
+s: 43f59d5cd84a6c01f6850d817dc851553a9568bbaf0b160895439e6b
+x: 2814abf1b12d69faabb1df4998d28402569addffa9f2d382777e48ec
+y: 97a4c7ac05154295293f3abe22f0ab777f8c93a75139cf4fac4c1b41d6077d028ba14cd65aefdb16c6075b063bea7a7897f521d473371ded8a4802e83d10c0e7b3dcd00887fd885c7711f42b1ef6e04d4a7aced8d795fd181f37545af4bbe7477938ff444b5f4068a9c09137e43d056c420dcb3419e20969baf08bbab0b6e2021c87f1d22cfd7d16a8de9d645fe81a7427cbe389815040dc6d6537a62e88404872f4c44e0f9b40f7c575fbcb14ad9379660a6ccfcfed24c8f92e2c41016daf9ef7c9659d941320be5fda4f0264fdc08855afe2d7a49ab749770ac6d13ece1ddc4c14dd31c1a9fd211041f7887ae6f6a22f62292d0a1d757f319d1f087cb9ba91
+g: 6a45134e14f0f89d69b01bafaf43a0dc19c7c6c69385627aac47d81bf2334f0c2d466bec936f42ceb0ce4c116488bb158b0b408e19bf55fa756ee525ca4afa10cd6a7b4c01373bed9c833b208e4a61ce312c233f804a1b7d6eaaa2065d94e3b80fb3bf69f02a3ed800f658be570835f76e98f2c9f9e12f3b72053256ec6d3819d6afb5f7315dd0f0bab12f683fa8d0ea03e9a8674e83c86571f618f818cc70c37f28b0f53895f877718a480c9322d92daba02f2e269b43ff0f7ea71cb5ce0dffa6d7756b3f328935ce4324a09ee07b552a382cb18ee82deb68a444b11073b45d6a08af784f59d3fd1cbb039a79ccf1b503186feb1fbbe34de5d08a82b3b7474
+h: 180
+m: eab7ce44f602e5e46c7387c31136b04c2444de3e3e4babc6e77fcc8582e7b0b2e32d96764048075c852a6624e797b82c05e479035ffa7753a92815405b6c29b905d129975fe782c5a46a5e91bb
+p: 8c464bff7e870c496ce105973c5b1e76011943249afd8ba65a9de2b11ae751b1b9b804e2e3004fcc5252c35578c9e2f94123f27aa57e2cc0dcbcf75da07729bd6bb0067b6e467d7df84c68e19b8f8256ef4d518834e1f0415aef0e7770a0e93ac6822d677c01257ef30870d9fa95fe74d41caeb0d73b3846dbb3b93af9f1ca79bde8ff6854bfed0ab2b4bb92735c65c340c8b85bdc9a8c996f6d2203f6f0690d97f9194f79e18fc7095abd45508bc0ab83e62802dfb05d699e0eac4918a2d835b485b20f6578f6c7f31cb44bcbea273cf0057c283b696b73b27711d1a157a2d463510186d6ea54aef189e7b4b1f4babe54b46c4664f3c938dc5cb6098ee114b1
+q: 860e8232356998d738fc5396e736c1f3f9ea3ea1d454c6375a69eaa9
+r: 562baf5d92f7f4f0ce3bde1dfe59c28a80950c734cd104ba55509f24
+s: 81a27c444abc842e0a169fc14ca51c2cdc1a953fca3587908e07da98
+x: 122da28d28802a2e221596e372eda8b4a99647a7439dc0af23d9c082
+y: c16917a7ef98fbc4b4b418ef627eafaa48c0351659ce2b9340bf06d768898d059985699b6f1643adc323f58a286c17a0a03ceee65ad6a15cb9410b677e915ab63b163bc698c45c8c17111809dfb37b40da712b4207c614c9704b698f02523064cdf11135d7a01050695667685a2554590a4a39be97bbb7c1edf125f0151d1ae6376775463623e574ac5757a2f812064bb7b529dfc9a2cbf9aaf62a072e6455ace8ec21508d0cd586e3383577d9beead1899db2027d691aba126c39a40e49e469b940d0bb08c8936b97d01665c94beab4ee66c96fbc6656c46faecfaa369e9db1219288a430469de7abda0e591277a04e834c00000540300194cedd545829b20
+g: ae0d1fc9326a1174a37170a9eea83a8278670d29a9d24671e061c73e8de80727a6cf098134aa2b9c85031dd5b0c3bb84c05ba5f832c6f79f06f22262430b924a3c9b26ad851e38d45fb0328c37ede5ee73e0677936303af4a0be4687f5f620fe44279b2418d2e0a44f8cc9b92a067908dddf657ddcd3fcf6db887141cfcfa2ffb8d20d502314d519877ba077989d30295c6d64b0d4d372090ed791859800893f397903aa9f8d7e1cbaf1dd340bcdf53f651ea8defd25006bdba2a84e70384986569c8d8aa7f89a49c50ddbf2b9a58aaac4ade267835fdb5c2c3ccf1747e12533391240b7a93bcc0dcc361cc52373f80f13ebbe4a7753bb0856ed2047d5feb4f8
+h: 100
+m: 9f11d784f8e47e86719b56f9cd024f1a4446ace1cba3b14e757932f302e9ffd8d5a8386a3c2f427bf0d8f2b7c090b396cd950ce437acd076b91441815fd02c1ffafa5f
+p: da02cff45c76fa856d3a4438a1bb11170bcde1316a560e438bfbf82fb23ed5277dcbabd5a7999b5f624179cff00a91b54b61d2754a99867e627711bf2b71dbbcc7a72ca5a8c034f844b4aecccacf6cfab0806418a882ba15861bd911d7550dc8f230efa785d44a92f7ad0cd8465a25875b0d6bdfcf5cf004080aa29e5e31f2e34f9e39d1a86ecaa3133ab5d30fb1db2b6166a4eab27b86642ed8a7ffa8ea14655be63dbb7d6913be0f1ef014ffa067b0e529f199a73838ef9309110961fe6d0b47e68629bde64320bcf22a6c470c65662a811112a49116958238569f2c513c203f20d7c9ba3d4ddfe52333e6108d24758cd1fdecbb025bef927d5b7de5a170c3
+q: 88084dd8a05e65a7d2ccad8bf291c3cfe359d86275fa00d0f6bbfe7b
+r: 1177cf0f51ccd66e410637d27369659b9b9fba311315769618fbcc04
+s: fde95ca6b8e2a304411b60f948055d1224c160f7ef54c49acf02f70
+x: 21ddadcc538d76b1534ccf7d49d33e0386c695739e4d1aed1dab246a
+y: 3ace1b3bf51f5dc9116b8145394558831999bbed64b9bc67b86f0bec08a5d4999fb3787b44888272e480c32c98d2c5d10dfcb51c73226398b0e4e52c34d36beb4d68c48cb4ffd4bdaa915b6e88c2cea851215130024fcaeba568f0e4a6ddd12c6f42a632f42a8c4dacf1bd99ed273a7031f0b264a51ab85e5421f75d1682c50793b5d6bdaa7c287b1fec37ee9a1da5cec2343b79faebc2c9905e1ef8062847a925daeb401040b87031f95137a28b4631862c330c41615539066caf87b3bcbe18aea923b7cf0ca20ccb24185534fb0d2aa5840b89bc2d0e4c81b2ba0855537a13a95bb97f73fdb0eb6846e176751ece53d29788a33f35f1a14b558d433431dd63
+g: 2e68806e9c519d334d339a560ca4c50c84cfa1a0089ac9e05d227a670d8c467be4d9f135c0bed9ebeeca3639669bb70d037ae7b23666eab8d0d852e4c57dfde9ac01a208a36d676817a6981468e2884fdd172b91023c2b94002b33e263bd5e4ef8d449c0a54e4b31767073a4e90035825f0577159521af7b0f57ad5d118de1a3bd1f306bcdb5738ed83cc3a5636154276eab02db87a7220a9aa7981bdafd4231c9aed0a0c5073b5acd60ea359e6495741278254c7f38a48624a6fd65924e327349927f0d323beab69fadf79e7f776f18391c2bbb7f6540d1debfd41c4e5474ec4dfd5271cc688711e291c108ba16d16b35551e448714218bafc7c63a3b6f1512
+h: 100
+m: 56bdf9fcf431424707f1f95f8e41d5ae8d233b76ac123ba2a80254890c42a7d630f867695b20845fb7b812a2f6ddc3c6eb80e62af4951370bbd0d5d03bda6729d940f645b5db219aa70753d91f122f3632446ff4d5374930c226c2e67b1e8bce3c5342a61d2c5a743b007da87f91c28632f1356bc7b5105849539573c2400bdb3f63c16ef501a0c3c4b28ae5dbae1d60009c75f6b37b0e882cc50fc0d6613f683c241e9ebbfd1762b123127ec279ca96f73b23
+p: b176d1c2ff6123e71ead83b0e53d774ab4819411d51d49374f827c7be67cfd76763a972147e650d7ee2b58b1a424787a1ba5cfcc57885d8fc20d892755ae1b5db7fe0231a4d6726ee0a9473b62f04521bc1fe1e5cb58f6b071f0d1718538901324f01a7391c91385bfee311de7134fa5139a8cc1ddead314c7fb88f923fbd0c203f6858f673bd3af9b2b0756a221e7fb5a4b0aa39a2d6d9a6ee46eeaad9c278decfe8557f496c5956a371691c916bcbe3ab43214ff563a70dcd0db1f374974498c4c138dbf97e54996c4b1791c09f02309ff9483c9aec3e1b8530b9ab6f08ed4290a120db642f02954d3e32ee96f56a813faab1443f8d5c3e998841f61ef21c3
+q: fd9b04dc79b9261c1dada8e16ab993209d51cb2baa977b67b25ca4eb
+r: 2ffa07252f12b3908608d524295901d2a3ea1245966d919e4cc288f1
+s: a003a4ba156cc38c6f68a2732d380cbee66d86cbb6743d7b954649d6
+x: f9989142a66b0306295616c27e0f527a8b0424a68ce793b1888ca68b
+y: 886c8b64d073beabbb0ff8d23d05ed19951e71e530d998c834c6dc326e787030651ceffd120b2b97ad551155fe00ac9096f4c1d2eaab9529d87309ba8ac5d3d7b7ef056ccffa03b8412d01ca9652cb9fabed1d320aa4469c675af8419b1ac9f59f00b9e836dc714384df193ed824836fef75a2372fd0bec1fe8fa9d8ea09b91b3e2751b87f50fdca8828d87f6a741c4b89ccd5eb1b741b6b9bfc717d1fc05b2056cc9ae9d3219c78038bedc459116e03ca3a86cdede897c818a257ec843f34391e7c7441f746060009e0183ac592e1fb714ced5dcd8091d9fd49c1fc598c627958607d25ec17dc57bdeacc139e960f605448e28620c391331a9d34439e0ec937
+g: 20b4663ae2a4f2229a799f174dc895c6cd940c9327ddde58b76bcf6e1975e0f0bd453ad576fc95961dc5e0c9aa5179448776fd83605daea304685bf21c61f374214444250c85c2add2e71af33afaf4a28daba107f3869a0118cc776fc653603604a77b25318e03374c00a56b789131d4ddd6b6addbd62275152f0cbfbd1a7e9ec6805606f72290955dd1753247c164558f2090657943e31e54bfd98accdaccf5ba8f8fd01cbf210cb77f1bfbde62cf4bfde04b6f10e7f394ed8e044125f0d43365f19bcbc6bef14a116a8cbe08328f82f845214b4c45f22643b080049b1b6e55e3021dbb90a2820c10f6a6a0cd29c13300acd0c3afd0ccd3606e7dadc7f937e1
+h: 180
+m: e63fc61bfc5818aef082f97419329b8adb42be9635ec7715c55614df0b12248c4f5a949785e375c937cc619cf1451a0541a9e96d939e95f76793ca01706d287c178f4224135535b5b816638bea9191ec623da6f564091f1f0c43fc164f4fa85033b287ddfbe358707bdf6bc360b210323d0219b835fc1f0f6c8e0a9f00e5003dfe206611dc758d8cac4b1142acae34a1a17c09bc46c9b67b5e68c8a84238399b3a0a1e0ddada5665
+p: eb81f1c0701fbe8a7bfb4de40d577203ca5ca10fd7b2552f25b21861e834b15f7b1698affd6cdf0d8a20e8be52ef8438085b0b90709e047d62ccce7663aae1ba509f0585bf5d4d69560fceec116c8a357f2a9e1f3f5490b178a9050658458b09e14d7995d0a439dfa32348c4f273d3a13912307887067b745eb1895beb819ca407325dbc316192da05cda4f83c1a7fc45f9290e94960752c010289c52a9abde848c2d89816d19c15f77846b0eb66ad97d2744f618af77e40765bcb02ca3a1994435dc29fe5e5d592dc2d4eb6bdfb4dbc6f6b7283d919b0d943d0b75b11bd74c337b0dd2ac638e1c8ef1dff8f448744affdcf58848a2ab7fb3f0198b01e05e85b
+q: a106b7dabd59d3fc0a77337ff8aee12dd41c5d5b087a06c1b9316309
+r: 50da9d43fbb6ebb59e9b4f89c1c356215b078d88e00608ac3e084a64
+s: 2087720ea3501f07fe32112ef4ff5eb029b0620eba4c2c68fccb0847
+x: 2d231de663900e2f4cc1c87f8addcbf745e2ab18f31221707368a2d1
+y: d9df92ed7c82e6da8ad7cea76226f1f8ee5d24d7897bb915ec69d0e778511d9f6ef9461049c367f21c6dc646db61f489c7048015e82f351a4c57e90bbe1ebd5b5ccb8b3ea6bd477ab8859589f48a2f69e16c03f6816da7572a7f6e59ec3f2f8b102ed070ed46db2fc475d9c325201d295e07fa425d604d26c9f572357c15c6e6d5f5bdbea77cceaf3d7f49bb2ae7fadbf857666cfd47b61c590e16947dc4d4c03c3d04e156d4f68b412fd3bfa07686bf88c8b9bedba7206f7c3527bb22f3e400333087a89007b499c36ea0d16dd32539f56c160d1f6e40798820bc6168354821d2757f34dbf17cbd9bef9fea3891b525bf581fdde0cd030e3b90d133087abc5e
+g: 17f4c01edcb16c83ff2a183c9079a74b767cad4c2fb234714d3dc3a9a55938e3e81c05102356b21f024733a04174d04c46c781ebf31b2909a22d42fdede81caab1e627ca1540ed6a802a25376d0c7f3af9a60a4c64af806494c753b937a25eeace16c19eb9a142ec5da70c4c5b843b332db8407e157dafc998cb39e9a67556c6318210872e922d84938619f70060ed5a8196f660d58ff23fffc9981c44f76b5ec0c580b424f04fc6adc13a391cfa1be64d14246612a902c4fb5156e08d2ad23dfd1a0a8c84ce50fe59ebda0e9a842d03608156809d7812a8cc14f920a5434d8f6b0db697dbcb8606fe0f38be0b221dc7b6dd5d143c2f67276358f9578584870f
+h: 180
+m: 875c4cb3a08b5bc478d925356de76d05
+p: 90326d8cee672a0b3ff9fcef581a182cd84b8c97ce86a960f094708e00d8f7d0417c74735f2c65a0569a60e1f17759b0359303a5a1319a3352883be4008c00afc2ba50f897620fcc2a337037abc9447428f91e107901760c3c6a9fc05f142387ccbd823fcb2a0d2aa5c55203f961a8ed68fb94d2ff6aedc5ee0d32930fa6076406b940e50e1aa4b46140d6bce87348f971da55cc3f24a82ee032583d81287dd50264103f5afb82e76ec81ebb3127a136a6c06653075c485bc033c1c09636e4f4b0a22f5430ce8aa4ce2e8a3dc3dbad5b241531730412fff4a5164a8b908b7beadd9922144b8d4c43dcde1f45abfd6b66ef66bb1d16eaabf05847014d659a419b
+q: ea85349913754eea1d0c7f5d17fc9d73c0e64a0be281d503e44fa927
+r: 925a996eeb5e8c3be19f872114133066fdd68e67fec7e37e4c96e887
+s: 8d523959af54ed2c557aea35a3dc4da5267dd6d7a4d796bd585019bb
+x: 24a7333c34fb47c3e54290b64b679730b0e6ea00417aa82c08c156f8
+y: 88c0777479a23d5fd944e098b0a3dba04b7aabca2a066e43e504ea74e3398417c960474d2ed194152eae7450cbaf4f0a0b06e2d79b4a64788fee3d7d4f122442d3d353f1f62e3b3dedf2f87956c3b849497891ed8335c4092a54ef0c5baa2169d696414f3b9d5dfe2436d99c52156ccaa3453685382a3aaf7c47060bbca32273cc998a9f3cfd6f28d1f997ebb4569e4134d0602fabd1a7f716de552de6e9dc59b7d1716e814cd9f0a1f4c967e447c9d666f295e5421a9e70dfca7ab1d8e57f20c952471d5fedeb266ce5889354ef05f97751e9e8c214138f5a0129fbdb54f1c835773791e8c660b43755df56d942267efe0af2a526ca68cfe6e04d2ae5fdc6eb
+g: 5b9a6be90c0f87d8dad70dfae94b6d943ddb3c8e0fca3f0f4afc6eb14109c611aee162f4f168224749cc8d3ee09fd5cad3f7eb309a0528c748187fa841bdd8d44586cd44e6afd1b1110423ee0d46051799b446c59d2f1ce8b06f78aa4675b31a99abc0b014ee85030d60aba14c01340d686ede6bdf6f9d53eff33cf831d6076999d6b4c4679e0955d5481b9dc6288171c77b645cd38139f3e87f8f14db77e3e90cb6df1e3ffff9cff84c258b994d7799ba4563146f146146f1880fc9db1b046d7383c388829f90047b08ba32b7e8b2a4119bee8973f0a894e85c1a7f06ba2eff45e1800255403205e1fee19fd6d70eb7773ca5820586e214562a27ca859c8b3e
+h: 200
+m: 988af38061c4a11029d5307b92d337a61702232860f3722627db830985282c755ed5ecb15bf2789c4b970342640dfbfde370325977ed8cc111e068da3bc49541fa28702ba98949e09727da7609555dd34194b63b9d1f19105138f4bc9d60d0c348548cd1594a82a94a517461db1f1fe852e3afbf6bcb4a6249a742a6b90a23b8181e07e2ce6f5194a9a5cd16a94862ab27a660fecbdc8a268b
+p: bc2392b05907cbef35dee577e735f7ef7b16c2c0d4f0d9d824038ebca5692c412821650cf9e3c5908bbbf2d33d6210491b14f839cc5faaa66adfa37de49bfe022eb2e79141f2954495cb7fb0c0f64549219065a0f9795b87bf3ef6e5c6903f3fabd95fcba0fd58277ad6411d50a456b6f7b8442e1c5c64381ad3c3071db322d4d44e90178f1a72f8b2fdaf89bf57572ca36f72b549ffac4cbe3b121c46f0e65a13191e8f78e4d6867c3003da47ab42491574fdc75fba00c55ead6cdbce078971013d0610f18fdb6a49dd5ad3e96fdf92747d3ddfece0684d597e93fb4384c7b80e267eb31d2ef5021a4577c1348f2e468ad80f85a3c4c1367ee34ee7337c89ab
+q: df8ead593056702e1f8cb93ab08b039d3049ac2c96956bc7c772816d
+r: a8fdc1da276efcf5fcec4eac7021b1b8634991200363d3d1e32f9029
+s: 717cc41555e9f7eac8bdfc7940b62878d6294e7b50cd5f4be03485a
+x: 9f04977681f073dca482c945997e213494194ab4b77e72d1eaa956e
+y: 1aea5d97768d610c0edd637781b5c5b204f7f8f58088badc7ecd648000d2a1c569b05e4a549a01e9150652c9e8243ab989d1c642d6a4ff9bee6e00d8fc304a2f0abc99c7618d4e83ae4a2da3bef9647e4caf998c99a3581d55326670baf698cf6b97343f015680859cec755987627b0f84ce389bc20f862d758968b1e9655f388445a0cc76b472155eb3936cef3bd31f206ef03a7b03208b6686adb55dfcedeaae8206ae350cc2deafdd65700f8a5b554fb2d2ebb0f01cd2554cff5f98b3738659279fdbb5433e85d5d28ac2b0332b3660eb71f53b723ad09cd624eb95d8751e40f2e1c0dd53029bad6c8509b2452dedcc47190f76eb02a58f4538014f8ee5b3
+g: dcb43f91c33f29334f634f868f870ef57c0a53a0a2fe1140ff0bda361e13d870bf30ec5184cc33ba961b584322e192131a819118186aea9898d8fe46889121b4f4d1d739fa04114d1b18b3e0768030afbd9efcc73942e0d57c91764e5e0f4fec8d17b3a72ed5deabb821779654699b9244b609e34ada7f870e07d1004905a6d39b2edb45fbd8708a248e74a32cbda5d1e1cd719f949f07479285f77c6fafbed2948a19cb451544a7b2593451e46c19e8303e378c1ed026b116a49077f5d460f2bb567e453f953836190c8a9cb9fc92a9d580f443e49c3f927a0e5371174737de3ec8ae4da5b83d099b0d9f32ceb5b0c216231e81cd2895c4a589d99ca223e1ea
+h: 200
+m: e1ce1f690064c2a0f1ed049574e4fc
+p: fb578b4776827c4d19d2f47bfa297980e31a8555e76356a60b621693f81d448ead27d48876f661eb1244d33b00c89b7cb79a77aea1314b04fa56eb6f878236fefc557d93688b83beae7ec313fd62628fca59080a6602280269cf94e979661f9899d165d90440d7ca607eb32ddf4a7728fd4f175839374d95c42d8fb9b1dcc01460681c2fceab65e08477897742e8e8ca4b6a18a6c31a517463891476865cd7640ae9b5220b7487277d36e572796e41b6f8d999bd1ca9faceaf1f929caad75cd090e23e1a6da9b6bdf22bd5433d4119a8eb196dd448cad32da3354d5cef388acb38d9443cc4982b3f3cde81d521dde1133e04fe2a0b3ba4bf8f7eed330963aca5
+q: b0308cba4cb365d2fb37339da569367bd03ca3f23930f44099686eed
+r: 30d68752d02635a13ebbd8f480fdc1b6b7c8597b3f63d6167c406d0b
+s: 5993c4c6e4251f0b2799f53af455b72458e6243d3b204e7c29fef703
+x: 6ae6c640986d73107c2ccdf9874f96e08b1774412bbe48eb17c6056e
+y: abf3d753748c120d216d1e1640d7007966eb3cbf1d80830741cca52591c3092571e1526c052f5b25aff81fdbc9d63c16680d8df8320e284de0d27b01e81cbfa4f84ba4d25034c3ff97e44000dac72a0f12ce774a31ee3f21f0f6b3a2014c0062295253493dca53d0d4b4c94d49acc116d69d7f114ccaf537ff8d5a6e83f8acb7c911d062c6ebd73b87b9c65182d201555a9cf25622ae06933f81689bc5e3df3411a53182c0365d6457628d3988ae8966d048953c837fd8be6f91eb0f12498810eb277a531996f192bedacdc862c9b9fbdebd690c414eaa0640703738e655882a7f2f6d3c6fc1b099cdbd47da65162ce8cc4180656a7a3b00e9dca5c85a59291e
+g: 3b5ea62331a5d0b21c4c455e020f128749bececfc4a919f5c877fcc919f1ca2bb5aac6fe81ef181d6331058cf33f4c6c9371768d126c9a60707ffc69510bc28ccf604d2ce1d596be3983039d88cd3400c9c2aa3b7e605950f748a46ac15e712b271a0356cac1d3baaa1b9e07b45dedd73baa8542af5f80c256633e893ddfd9b189def8624a3abed7294b592ed9d13724c998906a6fea0ee7c2d3b6ffa036781a77082609015273b9581ee557cb78af1c931308af842203cb9f7a7a5f26c3ec96f3955160a9009ba0dac6a6a652067a10867d06b95b0d8fff63d8cddd475d45cdc9278a2bc1203f83f59bec85d995fc9785e7d7c5a4f5452cb3ae3250e41af94e
+h: 100
+m: b0c7201effb15930174cabfcf428f6ad3ceb5ff85d3ddd84ab42a1e10fdf28d3dac7de9e6163a5bf631e662834cd54f96f2973c9441bdd40a471a3b27efb9ab4fbce0c53d05fcd4676058798da6a4128e9225c67f5848207da0f753d6cf8ab9372dcb938a565b5ee5799647fd91747de107a99757c08d49e5e9af205690cb371d7a043ede1b8c22501721886b9b3281c128badc8e76d91a5b709a5e0194079a15ca418eb535438f69de6069ccb7b21ffa10c3d0ce03aee4997a8efceab710cc0c0d8ae7ce29854129bcb629b4040f7fac3b8c968789ec8aa03d7c84e92c6218a3973962cb5c61999584d
+p: fb263cf2b81f97b5e55ff5a8e84b65058d721f9b2bc0f96ef8ad3980c1ee80dd69af539c60ac86daa993d150a53b93f838266e6bee6bb234c32784e2018edf370fa30bf9535990deb0c43c376dc224c286aaad6423e01c2596720129b0badda8773804ab266221b156b4f880262d4ada4976de1954d5efbbbea4cbd89b8752df59059706843a904e38a1222a06b463cfb6008689b6d91dc398627ce6352e9110d170ae6a0e7ef09b3f76c65b57e90f789769d3e6305a9d87a1e76c570d7e2ba15cc90c6e2f69147352a6790077571eef983d941952b1ec6fa3da1bd018f20e0a6a50644ce00ec04f5ae55588885d231c005f165d99175061e1843a9a06e1892f
+q: 8f6d2992082311367d0e3afb01a86e4b7395381d07760f18aa93a699
+r: 1e90a73e89f237ca86bad8e060637432c625476f14dd372447c7604c
+s: 142f95be07b2bd52d660b4a6d4ebb9a9d0fd60c2ec5003a0d0b502b
+x: 154a292ff521c6919b3524829b5b21238fcb00fabaf38786066461dd
+y: dec5227bf4795e73cb2bf1150a7a9fb189811b3c29f472da2af9520bf4771c5cf91946b051f805c9a7c5e2ca790a07b1752d1337b633d0c0a5bc4e7eebdd22d1e9b0e9c689d6b892437d0c17c0fc3007238ef672a53aabe49ef41d802d53b2eeced8c7635f733265c9bf104f573fbaf9614b4221aa2ee70a69f33ec1f6edc76487b62955dae27b735a7012d6d9f17805a82df1c28af63fe7cd0c0403d0b015d0870e2e8a385b587dd7b91e9dcfc437ad2d43f81cce08c3c372240d30853dead0e6c7b34060f1ff7eefddc196189425736d224ff0a2fc1cca76aa8c564deaa22654ffdf34ce87c5d23c2490bee8470c8fdc93d55bc120e653e3a19ce237e49813
+g: 5dfb6a757c529e26d3900d19c260b686038d3cbc0a33c73b5b956780b0aeb4c2ee189439e23ec46f034338c2a6f7908c8c8dd7e9a5ded649c24a967188a35096e540ead6ba1ddf76a206b6fbdce8c7fbff0ef4d0c931cae2bffe29cb26cec6d069624d2c981584bd8b8c5de42d3f92886ab85a26c502b309f75e51733fcc478a51aa92a09bd7693166304d518f983984d2d4603fcb5d31f72708af879a700537c53a48cf40b89518be007a69b42e342c637f23e610c381a1d258ee841d9cd5ee8f713605fa2aa828861c838979fd5edd1c35b9651917698710dd96eee654c42a9fff208e4ab9674f11b10f423ffbcd24f70fd62e6e844169739d1007130f0a31
+h: e0
+m: fd0d1023cd82dc0a90b6a59139bd65e2e5b0188070abfc422459fc77f2c536536e7adeac20023df19254a51a69a81068ab4fb8e964e503486a856725ba7e09a8fecaca13ca372104477bae7db59aad99fc9706f41ed2e98d73c4a49478a2c98dc2d22fd2a6fbb24ab31c44030a98521ab2d84312ba21be24159b56778d32b9ffec50eda59273d116636d50f84ec68937485cc1590c
+p: cc96df61b9406b260fae612f3919efeb302ec3f912b17ed5ddf13f0cc88943e6d6e440f3d48470de73c9c77a9e29eb8bb594a52f47a87b3ad15fbe31dd144a37bd590940e0d8629bc50814b5ac732d16f2031070b9776e5cd684038250cd371807e508349a43cb4d6794db47f5aa81983f0120208bdf249a3b505fea49bfce4f725ea47179f2344be81019080d4f3d58896b6d5819b809d36051f77fb9c6644d769956475e335d0e0ee92de7f1588f7017a6ac244441126599481dd1fafa0f9ba6c947d2824fb04bdf5dbbc3c02326038027eb6f8407ba8ed5ba7a4192ce0ccf16b64aaa227d675c36e61e1811ed47235233f6dec87130941305fe565ae1c489
+q: d8864ddb2b889744268232c0faa7949bb1efde4d93e59904f4cf7765
+r: adb1244036766ccde22c5012443f7dbc421d6bb2fa3d94d63ad8bc47
+s: 60a9c1734f89ea29172806dad88588539243905b08e43d99c9bc0269
+x: 88de7088e20689122fb5904005ca2b71091221805e96437912ca89ee
+y: 4c421ad50bc635cccffd890473f94fd7e93869f7886360be84c5a356391acf60c561106e239f1cdad77a21e3fffaa27d7518c582907fa066447e85ec44a27fa3fade0b61ce9fcfb0a1624d3d7f7411e18312e2ec610bd874fe42c7c24491bf487dabf705f3931346b417602942be82498ee44f72d7758aa58ac2e4dc4e69bc6ea6df4835e71bec484c5a30b32b2323702d94a9de3d5b89c7ded480a4774b3003c3634e0a865fe8f8378833983a735f68389a5adde28765f4ec5d91eeeff86d324e66a238d6ebf019c4ada43c67b4d5bdda7fc35c6a9a9e0e56480233423ddda5cae1614826e306dd617cf78d1d357e2c5757800f6e0071ae8fe9c7c8e29469dd
+g: a60b81650d52a438367b7219f9660d56edefb805eec8871125e9d6f229ae44411cb2b82a848fe235ec045a3af9ba4dfb17b09af61da95dc5a01d3217f716335ce6ba03b35d3d41e4f0db1a7bd8d8f1ebff3897fb124b0ac0a7442e1d2c884d181bc428165ddc89db585524b44ad9d9b29b1f30941a80514ca25002271bb66601450cbae746d70262497018f83114eebca18cdd65bda331e43947c66b13f12964b345cfe34b0d36b3fd4b504109366df6dc520ddbb1fd6d16c3391abcd5df32358e09c5e2d5d1187ef46eae51848a4d576fa37735667954f368f434fbb3895810bd029775eb25a6cea165d5073685e8ad9d14d57a4bf80afbd917f584b282a2ec
+h: 180
+m: d3951cc43ffc634919a5e5a2a51580b4bd8de2b413a7fcb13d05fed3b260e483c91b8d4bb62ab1a91a9a98d96f9e139add1c2c0fcdabc7dc8266426c10529ad0790bdff648572e98296e41113754b5db7c81c2e2fee535f1c6b5ec5edb733abbe9285d37ec7bfca4d5c77cb25a29c73dc8bd5c319784ac98593d1c69e751ea87c0746b704b3b38746e03f879116470b5
+p: f6a4c18aeddc4cd03dfd41b0a6f66624828b79eaee52474d9957a48fad4903facad7f04977c83860a236d716a5331ef273205b987bc4813ea7f9e797434c3bb9de419e92f890a7a447e94ebf0ca7d6f0f58237bc2747d2a9e4c367de73f8b83f1e76760305c89f316cf31753f7affae77fb46bb4c199be93f3ffb13fb4b54d1786a3dbea5f24013a4ffe7880fee8efc925180726431b0b5a7badb382f0c053f9c7c3fc8f7773b14561ceb5f2bdda819bca34d7252d70e3bc3dd190dd161497a7d087115c40b087d7df81123fc4c917b75edd3e4e08a870f6fda8d92ca03860200ba6be41f3db6a22e05ea4df77dade736e70260950965b137b61d3ca130782fd
+q: 9818eb04452248796eb475c76c717202ffa62da41c97bdbb2c731f17
+r: 6fbf6d05b5489e1a5a1f0d44ec33ce9f1ee7a8ca4713af186624820
+s: 2c1c4dc0d6de29c859bfcd01ae1c5d6956ce3f73025d186f0ae0c3ce
+x: ff7be78b86f3e387b18f8d9c7e123c847fd30497658ac91a35267e2
+y: 72ee2330e84aaa034898e53426042de0bf5dfb39b0e4dcb04c3ab986ea73dc3a1cbf592dbbb443e9cab7ce81e92ca5f4aa1156af9932e434c8975e041b69c4d42b8543200140fb02ee48de817f07f185c0cf23a446237b21d733464ebad78e318d48ea1f38066e2b5a61baaa110bc2e86b7c40cb3cf9c10a712e25cd611b30462efd00482c7a27645ee46afe33dd3800a14ae35fe0595187121c03831c2e60210d811b790a73233c410c4f33fece59d0985fe50580cf77af2330d6aacbf57303f9fa597578482a9a155b20710e7955033ce5c009d4e4eae30444066f03103b839a898d82f1b276224361baee7bc0e67199ff5735eca5545dd42846929118c8b6
+g: 504ea8f552cf026b84744849a8596cd4a857c371438f44a3a59d28bf060cefa7afb6f15e4c94f03ddb1d1c92e7ecdc820ae2feed6c326643b8d161a3fa863cd0c7663ff2a9c786ec4c59c689314774f8f7d09380c0f5ccd77d3716cfb96684f1e57392e1446ddd1d0374a466c2f3d91842c83446a8d41281c58b35f9168a6aa8c17477956e8a382848f2a115cf2aa4650b86905b581476db9fa4eb4c2b645d73eb64104e8122cd0295f91b5ef4ef7c04a40a6ecca251440540d9d8b2827b519edfed921ffe40b79958246f9ad68edb769046878ccbb24fcd3617b46ffef038f0d4a6cd499182dbf16314037a0c5fd760da8c39d66a0f3c0df77802e5e903910
+h: 200
+m: 02611fcde38062882444a5b6a5c3d113d3133f63cea4ebda150aa8e6c036770998e4a80d7608216c15bc31ca5a4a9f5c6444e492159b203b0924f78d5d5ee0b636a0eba9db3a7fcef36d799ca9b7f91d0868bfce0bd8c85c255dca3119e0c852fd95d9f489a7867e34b6ae06be414aca5201b83cdbb20e193566a4e108673a3abbb82b215c4b9fa5305d3de8f3d42be100369b4656d5586ddbfc9a79cf91d03a8077f98ccbb7d0cda9e226258d571673279ed7f9bdb08e7671224193fb8b96c8e5aab187526e438066c3da9e
+p: fdeb8ea9f5881856c3742d2174bdd9b0225c3ff89cebebd636d03bceb1501123523a20c6d0a243894605debe25bb1b28c88104a4301e4b957fb206c8ab7c9b85310089b86d671289af9b5bbac84928ad9786e1ac7b64c9d25d61169593faddf89585fef62bdabf66fe233ce3bf19f4b11ceca6f40231004295d54127e62ccfe983a8815b869d7723586fdad4fe2d9e47f1d31643ba9112353caa54caaa4f747c7254d568ce854fc7b9ff7563d24be6d9ca7d0a8cb38efc2332607fdf2c4c772926a26768226b6fc9c43acddf923dc6143a7d0edc99221d5887cd4bd478308f882eb6e607f817840db2fee8201cb69cfa121c5358915a97fee79630f4d2931053
+q: bc5d91937bea6cce705c9e283bc6a5ffe0ddd52c345274165a9f7141
+r: 58714c636e299bae30a22ee9e52d5760b0308d70848c9ae517b045a7
+s: 40e600114fc32ae6d904fbe68b857b053c453b5338221f556e1d65fd
+x: 88773e09cb596d940033af59011d1333cbbb071341bb0aaa11e55fc0
+y: d208e6cf810984e92c3c6c68b8e9955a9248e2820cf3ef7e9dbd4ce3f57c2607690db105361965a62d191f8a14951125a68458ce2a6440e024406a9ad92d999784831f1d484b2ea206d539847afdcb9f6daab94dd9d6fc24b8f6a04ac6d58ff58c32bd8da89a5b7590c62fad986311fa05ffc88a2daad2f2d7a4cd943cb52ec057fdbba815551d25d35b878d0ad5d9178cf226ff8e197d700089d95ee6696595365ac6d22f12ceee99ad6479ec2d5dc2e91810858829a3ac741bc814d705478be8df07b28af8df9cb0af82e691316d11ac0b74dd2a97468076225b3627e13fbc9e9550c3c340566b9541bc7e1e4eca11160323e756298762800a3dc58486cab9
+g: 339004a875eb778d79f9d5fb1980d1ee584bd30a34753562b876933028660e33d953b37d546e1994028e9a1c11cbac3b7be646525147bd2db394d039335f6cbe51da8b46455e5f500fd023f62f064538916f003da9a303a00923c0072daaf2e380eb8d210ad4f6299eeda76f76b216af03e85751a3b71d2fbb48c43ba893f53128301aa645a9bc8c73b34a50dd51d1f00bbc94cc3bf8f9744ab2d85d41839f1434d2317993175b2ec9dfd2eabace4730d3f092ef16c44472d6ec8313997c496e1d9bd7694af19d2c6ffcd1f002b3c258bc8097c58aa579e934c7122d036ec483b6e3ee834a2c3942f26a2689d22f39ee95dfd330f338628824d692bcad388115
+h: 180
+m: 55def5907ce32bb7f5cbc126da21ba22e6e06b2397158d896d77c2e8f85117fd0ed9992a90e697eef8982a0b99d788a02d89e2d488cd3c432deea59e822dc6ecbb0c16e9e5ba65f57a92329c01a6327a64d2398cdef36fd480cf5691727ccf903336f1ef53f80c54ccf4dcb9a26c2048318c44e4987907b8ebfdbaa686a6f3edcc62b9c66d693b41858c9f0b7415762bf72f4d1652b027facb042987ce1fbef45b8283d349b5c7f237bdf036c121f5cb2bcc6d326303426dfbadb32511b4bf902860223d2f3c086b3fda72c602c0
+p: d53612a532088b1cbd5a45b28d266851df5cab53d93772bda8d56ed2a59c73ef721316741962f0cd646cdf26eb7e44178b23ffdfe124e1507d6ddafbfc9008aa6a9d5a18cd6884a7f8602039133abdcce7c9c52c5ee7943bd7cba3be993a752a3c25f1358efbca30aeaac008a3705487c01417ade90d5ffd41df2c594b1b8cf9e63f7caeff8ec570c530f59dc7b209abd33652be7a1afd941dfbf0e6754626e7590cdddb690f6dfd1864147f11ceb2c510c045ec4adeb0e99896d61cfc3dfb23f792ab690cf1aebf8adae1883a2b6f8c5bc90fa76a2893a380ae5f9c4591af6f195b8b41033d7996d90b1023cd0bbc0ebcbc935e1f4094a1870ce4ce87aa0b45
+q: e38e9541655742ac02e7ff65b7782af8d961507db243965b23992bff
+r: d463a099b015848d385976f7083ed444aef9c50fe9a474d0579da2e4
+s: 473d9b0c3f15268d76aad9d6db04ab8704fde986a9abd435a19ff8c
+x: 1f59104ed4f458de451fcf5c3c07f5bd943dc857a08d5b1ce560893c
+y: 8ca19846b839b81928ec711726a170bc0bd9e75a174edbbb81cd9c910baf2eb74558f1459eb0f51f721fe33d3782512879d9b4e381b73d5a1379ef92ea5c65c98e9387c856c81def9f62a12e8f26d2ef9a34f5b949e27266186750be56181a280751ecee25c6d2f7e497586faf29237cdaa61ba2a298414873bb5df50408c5cfe868adec6d7b0dae2b6cea9d7665369ddb5e44cdc948063ae1b971b11a7853ba916caa363021fafa8b32ed90c76ee4eb3060fc7727007e9162bb25b069ce811cdf08f5d16f835312b620aedeca37063b83509bae3eac7846b6ffb9cba85b9b0b5e17aa59c8b34f2c3dddbaef168af40c3566c788abe49e86936cf3b4dfccf1b4
+g: 15272e452097f1b5baf2c098a98622859734bc9a04fff302f31998e1cdc52e6110257571736c00cc73088e419591d07df22c400f4c47445c9c6f9f1dc75544be90f954b5f41f513fe0898e976de3ca979d65d498766f23b835ebf7187993167ac1b47917bb3407c89359a0b61ce6621d1b7294979ba0012fa33fbd1526cd27b7f93b5782d37dead4425c7e958000391f91db665165b1a957cf78131523ec60c2fbaed799ee15b049efac0a9d448dd60530b1056811c98acb812f330c6c85e7b91bf4c51dccb12e17e4758da081e581c2d75e783ebd6985e4138c331209c346496ca30d50ea461a0cc14e699fd6d904b11d88282f1913adb227faefd9421db832
+h: e0
+m: 987a1d94f908dd7b03b73079a19608ea47db2b708852b32d575753ae81597b9878bb20962abc387b603530c0ee38b813c751bdc34ab136e71b8cb41c6220e3eadfc99730507c4b0267558a0aeb03028c5ee1bb37c7dcf7bd202b43a245c469d771a933cbe710545b6ab5b7aa432873b8e3ff0748aaaddb22cd24ec5a213ebcf27da754911d7d5c2b6090911e9df0f15302a6e3896b6b3221a66daf384865bf5959c5c458a0f454c84fce81b0a676447d981591ca0d81d787a6396cb37db1e0c457d124c8dabc
+p: 97f2b8c4e179de1e467917790cdf90be70e08d6713de630f9a7be512571f80c467a2e64052c5378b831ef0f4d84c0294d2d68efb910ec96f55eca47654fbc3344f0a610115b3848fd3e789e7f4c131ae81a1f62ec2675aff127475942512945cf162d9ac648622c1486a4100b51c764a4026f87c525e42fe11e5dc6df05d3089524000a875fc3d1f30a68a4342c6007c9325395689a6185c53459eb131436d711d2b96ab46173b88202b4558b426993840d4529052071dab93b6a5282d5da6b05b55b51e100e1aa132d3ea05806061324b5dbea4ef1c919055ac3215d01d5fafd1b23ef226d6981b7d196a9599a3f4768f2822af8c3c08da1b551f29eebd66cf
+q: c40af4728fc890581bb8c20e81b9dee3ae73a87b2ac92d02f4712d3b
+r: 55dd1fd5e8e5c875da6820cf5498e6baab510b165fea36377cf56492
+s: 6e6e758d94dc01f54dff552c095fb0b920bca7fd90fb7b6e7bf28b62
+x: b1bd22485d2ae1ca84e80b0595e77c34f6e1f8acbb70cf9d3f8a4d69
+y: 29e308b81106cd2f6d5c45a7546dafbfd31e15abe0f42814407ce9e2b5dc5f3aba5560b4eb4aaa1f3c23e08e96bab9b5f81a069168ea1311c700b2296615fedba5a99b8904744d7a251748ca6b7548c88b11492136938ba7efd4941d1a6a0159874b58bdd0c6398b68d2e90280a5758ee0cf08ab79267d18e1075ed3c0f9ab17e0667f40a830381343416be81129576f0c4ee3e53882871f610bf03705b652144e75c08d01706834e423b79bde44570d02cdfa48a7a7ef19c0e41a2cac5a2fbb3cffaa183757dc60be6d1de60e7e83600ca956558e0cdd454076a714ee595801a17ce6493a99bcdfa8734a4a48a28c6ca1470bdbe3963e2844491d2dd96134cf
+g: c4ba7aa3734b6ee990be72989b62100aeabbf487b4e8315880577b5d237d93e6ad24850516ddd4068978e3bea39a0b030b1cba360473d0526c30d6b506866b27d26788d25d7ce2163510d8e2072fdce73b3b4f96218cc048d8a82da7b6d18407c1d8a2ffe25ecc654266edc14b1b7fe56c72df87d43da6dbc0e0ff3b6a5383e8c849651fececbfebdaf2b89773eaa69ab746f888e1d0a9ffdc83a72a542d084813c302e6f1ab06108650bfd06466212c341f2f98e29ed82e0a7bc615d6611f508893b6e56e0f75f3ac8f5640a41fc7aa13bdeb25e205abba403cae13e9426d6771b2d85ee104d61090fd5151db8f91079a0c280e630857e385a953e61f5d05c
+h: 180
+m: b0679fc527deffa88d52a23c15fde67dee871d2c026fcc864f639f76eddbabc0ad7559c1c7fb53d806911d29becccc8b7772909884c30f10dd38e8e38bca03535b5834487fdc5025f61aac5bee1f3205d553a4ade6a239cd6bfffb22931f120e43cf665d6a16cea61dca1cb8bc5f392d231c2cae946e719fa69bbb77c1c22a73414dfb9fb8af1908cf65a782a610262ba2cc4cc3b22b65cff48eebb4666866a46542956d4627a635bf3b6dc87ce2ac2547b0681d9bd8b85c8427f7f5f9d6d9e794464b3f9d45dee80aab873b72fd38ac6b490110c6d53ac8232ab1deed5997d9370d6a
+p: e5a15b5e6ab4a53ee0829cfa8e6349152d9f9e324939e626edeff925d145aa1894d5f7dc2795c58678095243379c8c77e77c9aaf7f0e9b969bcfef662abab0c09e63d2ad49ae3469a0ba577ae05ff87ac070cd77e3fa9d9fcbd9b32e2e69cac2373ef33a46f1f1df285bcafc904e5018836ba08b8fd05f116c6b7f6c6f8ce295928c57ce4d42112f12e6d7056008f73b68a96e0e7de03f7a39b2adc253c467e67937345e11e6c543271ccb2c66afce6dce148a4054299441fce615e7eb8418ca97433e3624da79129895ef2f4ec615041311858a0fe24ec5b5b2807f43008bc65385d7a81e2324bff45f9689e2d0a8fcd4f85c39fcef88c995e96f31fd3efa5d
+q: a10ad23351175f14f9fd8a1d905cdea273a2ec9ed782d58eada644f9
+r: 411b51e54e3852643cd5bd73a75e6aab91161843438d20513d234116
+s: 4bd0e160c8532cb6c0826ad62c67865ea24859aa729cbc53f30885e1
+x: 916bcb0daf1df5d428ae5d5ca92e1396ca9f41109d9f24eae76a460d
+y: 941eee1b52814c58f793d216774553a42f0923f9f1ff9409feeab88102e9887a8b1b362ea7f1656d2f287ac4d23723217f6a7b94357eccd5bea305ac93a4dfcd61b34514105a5d1f8799d4f5e16f9bc9fdf78b6bd62925b3734a0a79233a1694012ff15ef64880fb911b8d0d29dc3c7a47b3be433ce8f26f90317746230c0264616a71685dc6e576ed983ab18160d690febc09de8ac0065bb86b78ad702cda1ec21802a7bfeb06aeb137a53063ec9b8b51806bf4c420917b783e5a6002d2685834df7c1dc022b14ac96f710ce9fde4505cb450191c5219d9f80dd5f02f5ab4ad2816aed508036017a28a7a44940258808f8c037e8174a4b62d7f43ea79d31d9b
+g: 4a76e7c3c75efbcd99e1a0a92747180499e1b0f394c3a5cd36f60b264537a86d3b7500df7f058f80da985e88de0eb32ad879d7a434b77643332c5a82712b1bec9d9803110a8352df3470efe69d72b39cd86c6dc57a002b3b4f676307091da78528b2fe01bd3284fe6c039333492a1db50344c41b54d32f5ec513a5b2110f58a32c0213088fde3a61408b9d10e6e1c0ddc60746af1f2246b6bf97b789cce63b644fb7e085e38473a439f0f4c12b80d388fc739f79a405a1e44f459616fa9eeb97801642ae2ecd1de69ebaceb92d8689eee18493c245d2e85c848a050f507874a661c2a541b09bcd612cbe8362b3f06b2ef3c38d1837fc1a10d8b6fc2cf96fcb3d
+h: e0
+m: 4453a61a8ff6aa9287602e0582d1b86239b7930a2129776ca02c7faafb88b41de5bbffc346b245a71f06d1c3d074210d470a8dfacc6e3fda19c1983f56d626bc46051fb1
+p: 87ca958345d017ac656162bfc65ea5f6489f1b3f4cbac525ad11c4c5deb637b3d92b6b32d7902e688449346c15a91671a8204b8a8124e0ab908ce816e3f9714328db13822bc3a222654c6ecfe61ea8e72ce4d5c20da1fa1f4341b8c01a9caaad6f38ad19b35cd4d2448f67b6f58a9bf897509b92e8ee3d4e0f987a333a3a086139e4c96b61a2423658dba02ba0bfe5f9ff2baa0e2a8e1dbc99eb770a22aea7f8a0b236e2f0b7c60dd898b92a8f6cb83d9e9acd752f7b28110a3ca94df68a98ce27fd2cb2871c86f08777a8c890a2eb1081250124e3c6bceed382a5f012d43f08fed3eb886a03cab66eaafc2ccd2574e51a2f712f89fe3fff760381255db073c5
+q: a64d1cf2e88b9720c2d4d71e44063512c9b3d3e213c7c219222e90ff
+r: 415d3fae30fb6e150eaede5c1c0328a76dc5c2076c1fde4fa36dd6ae
+s: 461030c658e6741f3c0179a2e7f5355e8bdc7400506f5d1f94fdc97e
+x: 72234df44a16480c7d83ae2414ec02a6213747cac26374eee402b81b
+y: 4bc23e4393fa4cbaaaf283566b60bd6893a9b50035ea540783750ea7f88f56b3228fd936abc6a8e7814ac2084dd93fb98efa18cb38ba0f8c556622f897c9a41d610a4a31a2e1eb9e29ee09b4eb013b72dfb0d905ec750ff096faa7421c824dd6f25bfa5ea8fd404205dc0bc197f6d016816ed354e009f45c2381ce48b451da65397b1249d1d58a0533f1f58ddff558f06caff43c3405487508be650af71cb9247ab622b3726f473315ef7d52aefdbfc06e09d832452b0786332e644e7b48b8905549660fddef226d9fb2a4128508048ea120758eb3a935b2c29f76c35f8a7981a691a7bcd4319beb132a8734ef194062aa141b89f959ac81e9caac6e42a33c04
+g: ae31ffa170408e74029e1830b447ab092549d61fcb641e134ab2899f2bab96a1dcee67589e4da87f186db5ec4a9cad99b8ad9694880db3b78bafd8c8d7e80bc4bcd4dadf4f041ba926c5c4fabba7d3cf507905e4d7491d78a3942e832eff0ceb78ed04c4ee7fdfc20267fbb702b2bd3a82e3701f678609c8346372e7924521c1fd04b844520eb83be247f07aad95dbdff5e1fc88d0e82db1837d5b5f2bb974e0220055ee4761f6fc1ba026fe8bc659f570f29d715c99d4f648cb43461598baf05052e2511b725682ce54d8970b91ffaf4733935a186bc4c935571ee256279e55752e5f8f8cb1e89978a416248401bacefb50ad45d3ced4e8665931596d24dc00
+h: 100
+m: 84f66f9b0e93041cb8294ec19df4d471843f7d3aa64753f5a521b7282447497cf89dbd63e56bd12da2596956572a2a8844b8775077862d77b10a1ae0db49efe7ff0897ae4be6edcc68
+p: ed8b918621d0fcb3a69f649729dd48f3cd566e4ad4eeb9af1e45c50c3601089ee03c7c7808d931c0775022bee2e1b1d4492d029963fc46a0f17ff16c67d6247d09e9bb4ebecf9bd9afd9c2dc1a5a785f6aaac68cb424e17e0a203ab942341af71ee686f5283514ced5c307fc576d97d331a9b1beda20f2aa016dfaaac85df83756126b71e5ef435b86f43d24daebad922bac5c2ffa2b56e36248fe08677921583a3b417ad6e6005cefc0d60b1e52314e6b7f43c3b0b2c898b63379449068f808d6f6b89914ba05eeaafcb6a7b3cfd207bc9682313fe705bcaa3fb34b0b0024347ed031ecf37c3f1dafa3110fd280e533d53b9bcf8e58c1d2044d8037eabf2b05
+q: f6538860b2ba6189ae8c78727ab7735880d6d6dbb38179bf7a42d417
+r: 20c684bf8b14bf8abb70223da60a163548efe6b5991891b1008ba9f5
+s: 931caa0ebfc47fafe271154236497c1df101ec07aa43ebcf43fb112d
+x: 692b6f944ef30b7446793119ae6ce0087c74524972329f38a8d9c102
+y: e2b80b32769ab8bcb6ae5bced1f348586da59ef016cb9f3d97c0f1ff00592f2a73918059bf9e8adddcf0ec8a1eebf5407359868f53466205898195776d8fc72e1e288abe14fcbad4d77be80dc07618e3db24f854dbb047a1927fe5e8c5d86f338a22901cc64b0be49e6a6873a680c88d1a61cb58e649c9ea5c17adb43db1a7ac323027dad2bc447f4af5bed702a36475a37b5ffb253c8337d5b2edaf94b8353bb94b2e060fbaf5ddfdda446b7a4f476417aeeb9791125e5c6a03d0b03783db37ca4ea13e15017c491bfccb0b8ad63e42056be910f7e956fb83de338ad1f52915c9b9d496b42551d8b25a73811e387fd8e75a69d5b4b88dbcc080652b1d836f7e
+g: cbc65e112646efbe130803c5bce884cfc3357a6c9fcab87e2f9b23f7798a67624f72eb47802172887aeda0187ff158c20cffe79224cd7bb4532287dacfc23c4e2d211f246775806bc9d7f68b57c63f42ebb3e3502e3cac01ddaacba5aa266edb7e0e7ca5b4ab988e4098e553fd0039dec4e131f2baa350f4d00e86dd04479128b8b67c8fca668770dbbaa12cfd0600c2295debd3ae1c81fb22ab751c8ac67029fafb5a9036e4aff9125fce9bea0480dffc4529a4eb648533060105fac230e9820523dc3a9d63d4e04251efd3fd7baf635bf9878047392763321dc21886bdf98e37d8de36625587816744f5d0d1095e656d549fc4ab872b2b944d99165901b03
+h: 100
+m: 671bde36b2e4798b51a308dbbc4818443f93b33a4d9d7ef5624ac76da8265d876445f40be5971d769aa747b6c84a91d50a066866cf0d37d4d93bfea6b064e10dc4557d1a3e9f9c20036752b8e8ece4ed074c162f1bc261e3b1987417e7b9583b396346769f855a37217c5675d14dbcd1136a17ca772054dd4b750b65afa129f1cd1380e31ab9abb0c35f4171549d8b79b6e6bf02cb45a1131adf4563282f08fa9370d3f582166992d97127f4738e5b95c7fe1d6837c9b6e0324395a20b5e75afe9af2d2d8c1e6931acdd1f15c3d75074d80ad7c51db2f9875252bf8f93acb67310c1
+p: b8f9c2c687cdf191cab9eefcb12fb2b62af2fe301b3d680d209f65940304df8e4f983847d6c6a3cff9d15d0bb272f0007441867e6cfa276eb3979d0cb5ac34ff4707657a2422fe6fdefec32220dd96d5844aac1a26d887bef213c6eb9e91071633084fa6729efd805fd6032e7cdf72848930cc024b7553d776bc7cb3f3dc40a5a52c9c7eaa0aa6b970086411a0b806abf8e6b70380a2f23e67f38933d850006b9f00b5b43f1052aa09ae254caf867300af17a55cbcf33165b8a4bf99a1664c1f28d7e6ddf4d7bbe49ab461e9f8bbb43a8f67f0b5a12b8c44e8d11bfce988c6d61d292eae8f4322efbd155fca0e6f2ff86c0d2057ea0bec74d1d662c7cc812cbf
+q: c32a07738f02b5182756e499e92cbfbe60defb24dee0c3cf7f9957e5
+r: 9111f2967744bbeae703cc72a0b55f510b6b0b6f55daecb9fdb842a7
+s: 5f44a2c44731d74f071af8742066a8f939a2e66d71ad0d2dd69b286b
+x: 1b83d4f87b4b8e9233160335d75fab21d94b17c68bc7d61e3f068d1b
+y: 804e1b31320c3fbe85a4e05caf9a897fa4ef181eb34d39b539d0d60d9c0796afc294cac9ad0c0611efa23494203ce91c5f2dfd78051cfe8a7fe56fb308c87962e50edadc136c69e647772c392dd6879b5af0c264edd38f404e83fc4498bcbce8f2976cde07cbc17ec0424300d54e18f65b07c080152113d13f1d8d77f9e11296ed83db360cc98e4f594832fe917c00fb3c0b5c577278b78f0dc064a62f9b37ae2ff28f684329eeae1305973958f289498d709336c342c053d6c530090324ecece392c56bf2a36a2473664f8e04ea3a79e6981b07e1eb216eb668232ac4c63f9438ef1cc56e223da404c3ef455bf7d3abf49425c4271651ee04a77907c3821a6c
+g: 580e939dcf92f407c347248a7a3bda3004e3c0369b879d421554497a3931108e4376c1dad48f765c916caedecd3ed3253a873feff693dca935d0b6b6d3d89b7a8a47d3796df47eb0d605ded12c53f091632af90abc0311d02695c2512c835326a4288033e7f154c529c1fefc8b8b3e6505cc5d5a5f869a4969b84f79b5d33e5ed8b19a2397e93029c68ecc88e3df749164ce9a58fc00cccabee339d59bc8c0397661a944e189b9e07841819ce17289527fa7b936879fbe1aca66567aab57795dd0dd5cbd6c79245697b6ed708f11c936aba54fde376561887055fa6c2d8fa63240d3952aee977b1c1eca498d8cf90721775d8f47d7f709c0d77c8b011f9663cf
+h: e0
+m: 3f0f120fe78ad61b138c1119e45b0ccf40ec67b1b943fd416411de4e390a1cbab1aafb8f6dac0cf526ae998452644c42280ddb1e6b0dd888a2c6e263fcfc589dd236930ac546c01d7cef15e1e0f56cf2e2f317fb488eeaddaa88ac1c43ac8c31a97b4882349ea1d3b2a74c4c3e6540d1752c717a2204ac2adddd4fe7964745756ed005ae79cbb3f19635b8eee4a02ab2ac6e19c55e8c70b023235454a706a088c25b
+p: fc93d66c9faa51c0fef6d2d87d6a8bcfdf812dfe0daa991b9363cb08685c5117c5e6395e26eb667ff61e140234cb2c15be5d197d8fab9d222906635069c85c2d233572661de0c2a949b45b1af76c1a7d8015294f1d45ae304d9a83e3c995387012e9f4bc633767549f29eb0b01db6416cf446fb17b053ab780ec32a28843405261edb7237ddbff9d27980034a24ba6a1fd8c901267d10fdac5ae774a8dc6f742f11a89103c0f968950d420d0abfaaf870835d5034681317fb2391f4731b4b93d4a62c99ad50204892b383781ffe384e90e01ff397c9c281a35cab3c2e28961b81b82e881a97f0cac0d52ee03d705a85a1e69f239d4219382e69d4337889cfdbd
+q: cd82a9dd219cfe4f2346007c8e946d812eb389096a4b6109b39c9edd
+r: 6799da04e5af4a6858caeb02948a2b64139a3dacd05fa52424762e73
+s: 12fe5ce14fee24f674557bf80cf5be3e67ce3f608cf8688bcba2b565
+x: 68845ee5952857b002457ce33dd9e110ccc0cdb27fdd9b92d177f3fb
+y: a023e46ae9c2f48841bc1fc291550eaf5106be36e71d32ccd2e9a79107afc37a6bb618414f1209cba4a4628d40cbd1f9acc343511dfc1d5c87f3ecb5846b52b2ccc258b6f17132d02d99bcf5f482a484816237af11c14bbef96309ebc2489a57d0605fe7c59a17c9199b4f7e4d1f4bd40f444ed6828ac430179c7a1b5223d60d0bf7e5fe4b2e5700c605d1c18210e141d905981afc99ac5e2666ae1f35f8e9cd4644f13022957cd51cbb034444fe7331198092c9f3823a9851c129204d4eb276dfcbec04f1f594148f99047410336ee2d0869a3b25d76f718ed7eac49a6867a5a61f6da53ea2e285224c175c7f79e2a05ca6f6d5510365fbf46fb02aaa5f915c
+g: 80c3d369e4d92d39427d683779bb60c969e2d64ad25e36c584a770d00d8c51e44a544219756d27b8e2965bb382231d1345bf93dcfc517442027115983e67034a2bbde12a4c043305cdcf6d85157f30af655564f21322a8aa5e92b9afa05d0241dffbcc357bd2b1bd96307d973c27c2e4f097425eefdd699451d0dd73dbe793fb9396396973e4283d89a1ed34337a6d755cdcf470c42a6570fdb3f1ec495dd8bff14d4346df57b035ac02dfce79b8d8c0bb43adf679a324b64be938a6d44eb0d1cdc48aa2b829db5a82591acfae6412ff5d74b3ae44dd015a1196afcf0fc42f76307b72015bfcb1ddae1f2021a663bd6016b15518db5e1470a06001330a278590
+h: e0
+m: 41e82ec0969d77b4551a0fc983029d5c71d5baf115698d318c724e35f20670502589f5d082031cd28d452bd35b087f9828b0e00408f50ed72a530140ff522e0e6d154825eb3fd27987308c57d7d248462068b58ff70a2ae73fefc68b581892119b9007f01fcc84479e1a30066d4ad183cce683113e320a9bfd2372ebe625e33392f03c408a64f680efb3dc75a609a658d0f9794afea4d1844869a176af56fe7eafd6432b048c85778800fe18861402e29171d72914cc04ef4360b575fde8372203840e503fcddbdd2a0e11091ac0ce6d33c69ac7c4300cace45369edc10ea7c4e5bba832ec3f22dd7cc20331aa90ad7bf9797684ebef8424adb9
+p: 8e99d53925eba8d0a9eed1863786bbd55c56a25622a0cc42db73357b2e4139d869c1706cd3276be64109bddb36ce4e4952340618a492e74d296c8a516b79bd526cd4f81a1fd6d58f13741ed80d1912ecf1ffda6f5fa674d4742ce2d11088a0e960e544c45c64c3f9253d985b0781b5536ffc9a7b1b8b1c97ba4d013074b016d39d5f958ea676faa8f2f3662f905677a17f3ab8ac85103217e843dcbc6c9d783f60765559ce806d9cd17eea7af87737d5a3f14e196408e109d7f25048ea3ea50ca03aba28049044ad056f2c1d4967cda53e755811fcb92df97259d1c3b02aca43df6ba6c475c8dc990df47f548be4d6f4c8eb5a20677b7731d37fdc65a1358305
+q: d5aea02e6516c9dc4fa96787184fd0971142e2889c6a9fe11b9473ab
+r: c9ee9f5c836adfc6995f8ae3070259ba6041b90a748fdfb7237d3b71
+s: ae0131c9da6076318ed2ffa19775cf4fcaa351093af5c933cfba62e2
+x: ccd9e373eae9ef4262bc4eec6f6c6be7086f3c62a524addb0051d760
+y: 6d77b0297298c9e406ba4ed8656f3a62c2eef2a2880a430a23a80f03278f583a3114acafe263d63040d6dda8fb4ea99e258f3e6177aa3e059cb7ce2dce1a3cf6b96cc0eea09bbcf8a43e58739a4e6b69018d688c9427105a47d61b942cf3401442f43c3af60613f15ebb83078b17d6eb416e16ff80683340a269842fa4a289010a323868555026da7ec942e93a65dfccc02367fb9ff459e01b11a8b21816cfdfcad4e7b46a4a5e61dc8016703ed79672d897f8b1008aafde3fc4606ec6a0c4e232b2a358fd13ee08070fcdddcb3df4ce4b0c62789c5e211cb80a132665726304c06f76b009b08c9c9ef27ddfc314ddf7bf94497423df27fe852b0fc6bb49c671
+g: 9c46da3373dc0e312399ebc0bec8ff437095b842cbb90cd5677613a98231aed6c0fcc66fc099cdcb42dbbc02962006ed02e2ae5e114373b0495c4446c2d51c337deee3a2c69121393be729958d5736ea0ace4aa37cb6fe8a4f8fe60368474d106a4245db7214ba82f4f3f5baefb7eac756ea6d20900d59499337d61d96d6de282e2b7e33b415da0e04317c42a9f27cca7f4d48b1584aa4cf6a3d69ecddb30ca4b0715e15cb69c83ccbcb1ad07b1f8be9c85b7638fe61c2b3ddeaa94ee59948abef693a49e45803439c9992b9c7be8f64f603b2ffc5d0c0680d217c49a5ce95e389ad4709ba921da9d20b1399a8a6880f2079bec9aa52450eef91455a35f5eae6
+h: 200
+m: beae243894a828b390e6679591b41879023f251ef94bc1be1f4b20220b90815dcf0f22add75f82e49c68056861aa054f81ac0e501389dcf0c0c721cd9906da87969b8c8efee1aa096df14b85934fb3
+p: cfd184e5dd54345dd05b2da2defe6b70ce466dd82f7f8c6e0131d9d7cf08500dec0ecbaf76b542a6fda53ac2b35995ef1c15a07a568229ac459a99dce47df6f183103298458e5f771f5eacab8c7323847f38ec93dbf190ee3a871835558ec4da231fe8cbd919bd0314d131544bb015726cb436e9e231ce87df4aef465788a44fe09f579c012e17b4d9b828fa76e3ed9b125049c6d2d86da7d6b1c4683c2a6c7ccd377f57c1c7ba88d763973ed6f6cf67a1c23950e849318b461b10d2b3745f8f42030332703f3ad909ce772a35224bae4db506b87d79be37d69a27c8a2fd128c1291d0db9aec755aeabbe8e6c66046408ef576d5638a5dca8d7962a74825ee87
+q: e99ac871cf8cef61c9e7597062183b67e4d76089c8e1f41d189b0ff1
+r: 7d5511d9442b3f229b1b5d3febd517971b941ea3801f04b800b5a67a
+s: cf7d37e2ef2f69012338bc79413662a7b3d274bc661aff9d15d15cd2
+x: 2a98f662c3e1a928507aff57edcfe762310601b15e2e6d6ba98daac7
+y: 2548dbcb4dc02af44133b7b6dfd32cf20ad4ccb8ef934299c1a44822a12704e61eb383eb69050738b4188bd0e9c14f2fc15a22510d7f8758b1a13357ca67c71a1bc983458a468dede04cf2ffb3981b5c94ff227ba75c94eec70ec657ad8c55bc37aa5b894996cc7f04d27f3b0d324e5da54c55a73b63f79550532cc7ac9fc77e2520999b8d8b78de0b373038aa6701e447d620142af2459a7b03a49babf1d39fe62c370d0191593d1d5ee56bfae700c2a31d7a353088d589971b8440ae6b41ba1d4a129fabefe745aae22892c5f1d01696b245a62082b81fac6228ffb0d96f8816c759c4f4dde3ef9317d22a3d0e75fad4d55caf57cb749d6809362f8a4eb5c4
+g: 453e4da5f146e3b4a7ac12dcde333ce1dfcd28493979e654616e7acf1e41f3f36bba455a4a7ce014a036924f29b31de48597ec10529aed74487c9d797c0313e4ce6517800b8b2ed61ad9ed872c6b118d1a0fdf69c2176851a2476099360954dc781bddefbeebfcf78b84ef2b854a3d6a8ed94a873316798e142d2caaefdf1e713bce3520e0e58049bc9b9c13f3437cf91c3194b916944af697c6171ca10ac9d5a944f04e2a7eae3227217e87654b58cbffd403c9dca937693e657a0791989ef9631a4d9578388fcc34b4ee465ba21bf657203b49f66f72c556eec15bb2b339c3938f8f83aacdc62ce3f63623044bdd74589b2dc81d5f4e0d75e00edfcbf543a0
+h: 100
+m: 171ef5556865fed87dd6c0c2ebf8ab0499bb499bdd98ac7ef7e733c42ea01f25e3119cd4d0124384c0a1ab9ec4783582d63858b4b1048b2ba1a724089dbb68765ca030161c00f629dfc084ae8756a66a75ece0503e182ff00485f81a63952db86521b77a49101b016905b172d6c64e2677d8054e0ec232693fe0a2829420063690873034224eb44a0178ad5a3e4f21e3996d5141d1c28bfe4bdf5e90f64994f01e196cafd8eb79cd597eb1bd1c11ce53d6014710e983563952d93e448989955c0bf7ccaa9d57da6c7393a4843a0942a418c00725141b4d2d92e89dbba1ed426c3508fd775687b985bac540
+p: b5ed35893934cd2fcf4828d13a23adafa3006a3e8f7cba9e9dd833729c4296e130ba3b96c10a98fd7c1208f626f836ee2efc3e01467d5932a26b7ef5912ab39ab956e48152254e827cfc30000753a9e4724bb62b8999b1c5c1a341a0d9227b8a091b7d65d9f07faab94a0b4b002109608b9c78550b33c06ddac21071c72a67b09a970d250f51b89452aa790cb76dc7a55147c8d6554d190f73020e964afeb44bef366c94c58fc9c62f0468ac06a059846b0038747153ba6cb5c93037ac4b18de245af1ea2f258df715638274dbee44bb040f7cb956f95ce3da0bf76d577af48296f778ebe086bc9909dc1b1658712c869100fd25bf3674c8697d07b6a32806a5
+q: bdadeb9ed976bc0cce7ca75a318b5016a85e26e67c1aa2e4376de135
+r: 9b9cab35494eae7156806bbe74462f8e61535f735198f74a078a4ba9
+s: 2299f3fadec636bce903889db7afd928b5a1b5aaf95afc7cab2ba29a
+x: 751a207b265d06858e2d63fd18ab370c0a7c4a546d94c90168e49519
+y: 5d810eceaf1f9e1813141107e073936efbea24d50bc9b755f01d026f61b5e8cf8be23a62b48551343253420c1f59db42c5c129d2c64b4b1c39eaaba9f9d2cab6ac3e99ee3ea6398c012b8ee1c971bc2f0f264724cb7bef744302f24e42f9cdcc39ebf2d27dde742217c4e8ceccb91930be7bac5964939b42ee68ce9dfeaa548f3b24ff0381c0996745beafc49f08e9c04e2f9ae261d2505d6e1e29de05bd7390fe52c64c36b36b174ced54d9fc77e2f7ba122480c92d8295c4054116cbc7ba3d5e1439399dea5433f14d9d5bf6de275e4e6720bab7914bdef4f36996ee44fa5039e21691e843153e5430799ced0fa3ed65c857e33fe14d611a0b8792a5818f3e
+g: a738ea71b71fb6598aa9dd1c5104be3f98a01ea15d0044d16042e2b7cf84816569a4c48fb01a5df6c62ae26e0705b98ce5f64745d4356bd27dc335f07c00304ca08804ed04294771296f3fbb55a8a09b6716e2908385bd0faf9c572107c2080cd59d7d49609412db47757072775b2434de14b516c14d5cd8a91b8f500f5d1287365e9fec0b92678cd43cd97f6eb3344a2600c1ec4710c4d320fd8a52811ebcd35495172c184627153dba8dee136775f945d68ec2e650940cdaf3dd58dd1bfd67e7079b7b5cf02f3df3e21943ce4828b03488f3a436e0d487c87ceaa2ebb08bdd9a15005c4b4953e88caa3a669731dd0df4f13dd243a6c1ce2c891790a5fc33f3
+h: 180
+m: db754c5e29cd56d09d53bb8686ee
+p: ba2df3cf83588c1d78cde00c50968a4b296f234929c18b00c64ec69e5552cd97ff2af464d2af6279cc6d8904edcfe4966a77f0e2554e60772e841bc69d4bf974e87c99e7bed40f1ea7b428ff3b3e9b07f1166df60a43513233c20d1ee7e76ff277a9fc72a0ddddc667ecaf98e1c0d5c323dc8703e4fd35b872e42d87679979785958c30af350c09549d7b98771e78f7a76f26652f00234f88391b52d4ef6a82b53c660ef074609f7aec8f90f4b60a4e333f5b9112cec3304d0e7eb829e2f797e0c2b6ca71d5ad162d53a3ba43d9ffb88b29f9d2f4bd2a8b5ae4345f28fa6ff384183d104b08851870b4007b6afe62c277c01a1d3ac3af65c9ed9730c19346ef1
+q: a5fc20c1300b2e62e3707225145a87da26b33de73ac86c3d77d797e9
+r: 2e32cfbe4943be369917cc83912641992716b5b46708e6631b71a5a7
+s: 6d920908ec2ad831e7a5d6981d27c09c2b6c67a4aed42387557a1cea
+x: 6c33715a34bce82fb7fe7a0c00c121d606519b9897f97399dab7a253
+y: 86a4bb45980a1b8a8da6bdbfcb0d7195827d1b2acb3dc6b5c3815895c81a124d17f1edbded256515e0c259db4e3fe10bd942ac15f5a6d186edcbcefc1718181781e0a9117367fa370b699fb0902799e9e79e8a57114f8839816aa976705562a407065fb2889d1f3c8a820e90fbe94f533b19c4f0be356e0baada311940d5504c42e8793af2aba43a14affe5d2fc5e745489ba8a48c1a720f70364d59eb969b4d3009320214b6f691d275d9ad33aec25dbdd6db4f4a0f8ad15e016f5b0809937ce1b0f4409708ccbed0461aa3a0fe7804e3fec9450a60423480af158e9f03a0f89d359c9649d9ebc65e405f670390188fa41fb1f2717627fae0cd4c0454fbe963
+g: 86bce785ee3960759ba5a21517cd9f9a8d80ade9ca433927ed7bac05d9d93e6492cc7a9cdf8ffa539c9f3bed7be29b3b9ece6956682265a6c76e5df78486d510a804737b4285fb99fa16de20afba6a35d6605a1ea94dcedcb4230cf42c617e55d4746538745d4484a4dd41167cead25b91c9be6d6eb13e4e10cec30e4177f1fddb96fb62eedf3d66ecb2871a91242bd7c59b3137e1173399cb4fd5f42a5ebbca0bb0f595ed28f8ff4e125d3c1159ef4fbfdf6a3a7603860a28c499ad53b9073c4b30c8b671c7337cc77e3a982728949a9951edbe56162f9a1fd4c6504b64fb94b8f48440c47e8da5f61831bd1e8a3ca42cb4aacaa4b3395ccb5ae57b6d4071d4
+h: 100
+m: 05b6b23ab73d35c686c61684fa67ef8508ae441bc87ddb1a795a5047e0d4
+p: c7733d50aeaf27ba860c4b3520a121337484a7af361d1d2575715c8e86168ceae5a445f82b98e4c6bb124795a2663a27d0b45ce3b3c3259cdc445b60c80b714ca5c548a0b3706c9a509ce8448e60c93b9789baf862ab826d892e74a3c07bfcfe5d24d0d55a2b08949e6e66560dfefaf18d4fcbb9fffba5435c46f2df719c7c9f5b0707eafa3c291cb06c7f8bec7a3eebe726a3e8e7b888ab27711be5202a179cd754e6e7baebba9b261ec95657762f9a3d68077be7bb448a4d2b98e80741273f107a7310fcdd5ac739098566e1c9bbd817f59948651234038a1b83743d95d52af1a1491b7d3003e5269370d26258cb656f5f195899e945aed684fceb03327a25
+q: 98a603faa78c4298c2eebc636c4b98af2f842be6e6d34a10d3c7d24b
+r: 6184147c3d5d60681e15cea03235af9561641afee5dfde0407225cfb
+s: 7fe7d07aa35a9542f482f8c2c48aa5935ae13dbc21c967a47a8af792
+x: 93f4d5234803ed56b01b8b37e0950edf81061990dae6b75a11f6906f
+y: 81bb903f97b689b28fad927f5ec8a79cd6cbde1d7074cccf94d68b01cb153204cc23fac59a5eb639c7a4d690c78cebdd9948122ff108ac0645020a19f16388920906e00561f5a010a1a1a5bcdc2cb6697cd91fb14f3fec0249cefee1d07e1ef51fc0a54ebc552b5622cf031fca16acdf57fe0dbbd48d7324a8c852056f48bfbe7f9aec3ae49166314016ae01c28db6ea4ca8071c98cf74fc74c2418cffe9b0d644b4d4690dbc417c84cdb0fb6b6d9d48d2aa0ce3cf08efe7ea2508e9901af0bccd133a3e3ae793296e94d88c4270e32633a8326cdb5961bf6ae2cb7cabf202b649003ef48a172042c8bafa639fd3af79ff14ecf093a3351f2977b5ebb12cf735
+g: 2e442eeb1cd2cf6e70de7b47378ea1ad08b4c59fb394a4df17147585198032839225757d981712cfa0c4711a6af7b0ac7146e0072d9d1e4828e64f1b0ce9222fc3cdb21847dbee96a0b2d033246f93ef02950d8b24d2f9a31ef9c097d9fd7cc889accfdaf962f690afb26abef329b22c5dc7dc44c3dd35a1d157bf17b19e4d4857deaa379bcb7b7b394b8bcc1a92b8e96cba5fe9fd54ac69e074e992926e22de28725f7d3508b582aaa73cf62a69a7b5db6e67aed4f60f81fee5ae4bc544319a6b8f2e027c73668b0ecb574a3dc12de1ea499116385d0fc9dc4feda09ffbf8e93aa34c4915e3b8d6eef0c49711d9729d1cb54e4f6bdf8a44d8183c9af027a7a9
+h: 180
+m: a3000550
+p: b4be8c422fcf2f7738b8d7172ba21905b197dee42f8a2381e55409e93dbf091df3105ece90142e429598dfc8d73c485134c823ea2a665f53d36c5cd3791a7e9210a7eb1b768a78ea82e8d01185a75aaae32d1da61b6baf02969c8a43aa858fb67fc2f797dbd3e9f8b2d24b2f04c414b68c5cdd09e486b2f50fe8d4c93dd54ab8ab9bbf421e8b6aa139eb44fc807be228d2d7dde05bded318b80798b30dc97b1fc2ce68529ca9f8c4487bc0b47618899a59d4563c982de39a66c56b1340f49ad1adfec12199447e3e9e898e2f7c2f48c79d68cd59628b188e3b479a225ce6bc291eedd49efecd117a6830d951acd01b80dece07c056a7ea23ac687fba947e3bd9
+q: a7299d55f43412914a78c2d8ffe7b299140a9f4417d9fb82d672b303
+r: 7dd5fd7c2c4fab27936da13753844a46f7ce20e0923966712dbbca76
+s: 8385958eed65f9613093c06fae1adba4dc9efb6e504baa371360a7b5
+x: 4eedc9b1a84e2e7a562155d02fdc7b4f740b8e1cf7c7700256cdc2a4
+y: 5958dc9f8ab723d4155c92ffa6a6d088d9b63d8e8837d57d808b9e1f8af350c941a29584c017e92758081fdaadd827e3bf203e325ff35e131ebc0aac492319c2583876b0a93693a012948c896c6d45dddc98a9b39f07b03b4e84c0408e1d5b497890017bf006dfd0d1fd7c0f186db30eb3f58079402c07402a89cc4acb15a2133bb11266a611b1cc3f8e29b02a67d31040da95d7d44b99e2605f471a96a82a721995567cd8337b4ccbd1b5ca688a6b1fa19da8dfa1e5d93d872ffa9c72048d663a17b8290119f1e3e270076f46ca05d55e4d2585f46b69cd6e7b96979bdf6e4f8776857f00c7adf4ab461ed062e4f7711f8c3c14133048c15e9aa15c8a9801c4
+g: 3985beaabbc161d212d760d9c6a15a26755ac67b03671837937ecf649bdd61c181cde403f04d81e6e620b88709c767c6726aab332019c16a7d70b81efabd4b1fba145032fc4469aa77e41d3b3b983cdf1f4b05a1da0049102608daf29747270be366a6cde0061ecd978d554c2d77cc621bf5409eb965d48b745a1233afa046ea6b4cf4a0579ea1e9157c8248f3cacbf1ff09428476f9455f972c530b26515d2fa8fd62116467307bb304b83299e8c8606c1884f269fa54117f22097fd17aca12fde520751809bfa0fb5d7024025286c395a9f80230a5383fdbb0df2406f48b26de8837c6b51062ef0bc48e58a577a0982b0256f4ef1a4eb9d58eb5cd2065d7c0
+h: 100
+m: 71af351e12bfafaf688e721a5765530addf9f922e29e381a8ce2f6f6b607344c8203da7a5113827ec1a13ca683bd0987bf1c5167c5900b0c75a25efa2d345c41ac71feeac9
+p: e9726b8fcbf273459e2b90864181d9ad1a2c9b3e11eb91c1bce070abb443d967dea05dc14ecc5963f8a51d9d58ced158ace32b64df2e5b37025efbee254097974ffc9ba806b88c1adcddd674f154489bc18338e76e65f351c1c6a515a26e3f1e35b2d5f0f4df0c6eb9855ca4816cdfec779fe4f4c4aeb313c70e5c480f38d9bf11bb742e90f07d86d89623798c4e39161e5350a9bc598125855bc707e1be3019bfc2fbee3ba6fcad5f934af34a996d3fc9201819f63ce521851d63b53daca4941801a6aaf7b07b25316b7e100e8e85fe13482b167bbb4022fd4cf625e2e586b70c51712159da85f4810c29ffc5f01a1206118d80bbb8ac14e21b8ec603e8d133
+q: e3190e6a620e4d90764ee55ee395475ed0850ce40a35681df7c2d99f
+r: 2d4f4f8d65e2309dec3d45a2958f161ef072ae323d9492d42c993ad2
+s: ba64abe1beebf7bd3f97535a1df8479d5b0715d21f5674b2c41b8e03
+x: ccd9bceee702432a7087d98249ebb29c6f4c6a8d560aa9e02ddc7f74
+y: 61a73ae04dc5d6a97a60ee3077cb2f9ab1d1f3a89c575cdede58f555bb0b2a0e77a7b610fca07134c0ce79738d832bba5b0262932d6261fc9a2efa1db38f5c4300535a2d7fb05bd9cfedf3a101448881252b0098607d1165a1bbb935327ad31926205794d899d75492ea647cc1e6c8657242c06c71b1f22f027a9024e4da7ae4e8e9aa0a3cd52fd17a510494f4eda9efe1efb946d0744a89e23af552a1d554f15bfc1170f54f4a0ec28e5558c6e023d56a18fc9c8c5606d209034d1d6a5215acb2fbb42663b6c3520ef6ee7c19ca15185ec1edf793b73138c72cc46e712c90ac69931036f98c3fdeab7a3cd0103152023f66fdd26fd7ff2f9a5c9b5c82a3d6c6
+g: 8e080f1ae44415033b353a103295ce461780b585ac73b4dd2c228e4ef394dbe8938cb4904e02ad6c80bf8b0df54a41173d64dee46869794757d0d5f537e93551add5116913e6ec75707557bacc6201735ca3e00d45fdf0557567eecd2c33b8ee0c16c9dd84b676c1f3dc30d0651971d9ded004ae6fa8bcb72928e28d04411d39c2553b9546bae92b9d2592baa7a809b061a3611e6ebe9491a09c8fc90817e6950741cad75e4ce359e6fa915059c9522b32e074a514cdeb565352aeb1c285a1cc43a703666410bc80cf76dc8099c8062892f0d9f91c90ad3efa296e4687fb0930be898cf9e62ac8227bcdfb08065571c7c71d301420554e5e357f6c5aaee371a
+h: e0
+m: 9fa8b6ad550f06912ec512cbf5fe6bf473e003aa3f91097feafbc89376a0b046d5a9a4da9e25fa193624197e97ed3124d3c454e4388853cf29011406e4b6d0a14cf334d0284c31111e0c5b4eb332237046a2cdc015e6a9671779c863ccee9040550847d7e7e67254fc2cdd8dade17bee877b137423131f4903abdc33f5a28c2e673f5100d4a9e75164d1c37fb9c99642
+p: a9f1ebd3e3a97e9b365540ce652f0e1a7a04fbd67b59f30910dc868bb40aafdd6e670af8605be846e8135981d664449439b29408e825a9b92e35ca9280af46f40836b7ca4916c1dfecc599fc9fb99d9decf63b2e7fd19ef426702664a73c2bcdfc2a2ff02c5664aa9ebfc82f45f2dc2a0230051818c47eb1a36823686d824a94480d230369c8e9c65fc6a18d4956681af965f0f5ad86aca76b13aa83415753adf07da0fd147a49d444abd51e49d563ac40c94733aa02909c9a8de20aaa521e6be57c25766218b247b3a80379a3fdc4367514f437b56a490893b09082c36756953d718aa4ba7e35e72f89bdcce2726a30f31277f4d097527266ab5db08c1251fb
+q: c48115bc09a3c4a8656517b942e2965b70ca315ae52397d8b631bb6f
+r: 3fdb43f93dd63ab44e9e2d05a82f9230781aa20f21f5febf377a6151
+s: 5b610f346fb2858f51386077fd9ad24dcc97efaac565b5a109bc54d6
+x: 4ff49038bc04dcfd7ed381aa3905c6497f6161ad161c0dee57687790
+y: 4af63ecd7d0956363d84acd2042a6bc348d4400bf9b8035618d27342a6807642151804d4ea382e192ba6182b41003642a5fee22ae6d00a7eb00a62f9e6c97b2da2df1bca7656a5812ab6e4f9fd172c626b7f8be565216f280441c0fc4daa25c4b30f7c8d8ac72ee7c4689d33298d06d4f1e61eef0b0c8599afdf813dd2e92abd846151509be395a767fd91f0e29364b9d3b1dc29e3dbd67b67e8e30837db7913ffc50a7aa8d9e786859d5c63afd1ddc744fffff558cde6bd98ad53212d40b13e1abaec215109abe68f77345338d0383aab9151567189b6ca08f6d5cfbf2e41016738081c9aa191b9fb482ed8eb405e8514beac41d5575af2260743f69860503
+g: 23dc7e43338398db09937cf312f027a9e7739e2e743efb0fe327af438e23360ca00374222b530e9a9f1055606a2798e7801e0dfcf9ed6abda9b8bb9f59e22dc0f8b42d029a4867656bbf6c0dd506a49c732f55c34b1b115fbd56ba5ef57c21704a951efdf2d439d9570c1c63a192045e0fee974fa84763df07b662c26a9df5171b43283cbeaef0bbba4310c4f10dc1e7ab50933a2689823c10309239a86fbd8cc10da93feae18f511cb378dfea68ba9b18d9619081a5372433d9c02a6881c8e4af78294233c3351886cc9216cb46a9dfde0b5fe223f98f790beb09b8b4ea9df0cc6581c6bb674b52120b1d081c766c7d2337ecc40fd404759c527282cf32a51f
+h: 180
+m: 5c63c596f629d155b601501bead8919761081a3e1021b17e5e3f0d0414d2eb36f23f510f7ef4e9fca9ba90ed4b0eb35b26f58f9bc889119a7bb7b1bad834e404f5f0735a0bcee9a5ffd71212b729a67983363ec23c5154a4becf70bbbc6e0f8bb91c9c98df5472a7f4fa208753d6aa603eb51715d44744e177e0d65b0cea1e5cb29b2ee2b65903ff
+p: c3c5ec55bdd1a0e940df1eb748b0129c628b57a6eb492f270ac8ca7531b7add68da08c5ac949de68c6093f376c4536ad38f5f84bbf09b066d327b9c0c8ed58ed9f8be9d80b8ad01650e09f2177cde2e5c76f300e017902b6d989a46b9759defa2f6f0468b0a31856049e32b1eb1f86c45d69587ff2c5b2fa1a0fe3c8d81cf9353817a74feb6c3752d0dde08e1689ee8e7870a9b7afa7826518017269021bfeaa48f9ee4a401d277f2a82dbf237f7f99a1e44d707b953ab56ea8b063e790e153cb69d2fb4c4f54922848d9e34fb5ea8e25434aac3ea037fa1ad1de17107f9f8ba9c059c86748907ba0a670def841df2ec4bbece9671933d8e2062dcfc67023c3b
+q: f59d7b37fd04e2f3f0ed5fa43336dd951f2e3cf4b1287fc681c8aced
+r: 7c1140bbf1b2aa6a9d8afcc8a0e7babb99e7f3b61c55c1ff9e634e2e
+s: 4b68b54db6b0d6f912c0d5791177bb687bef89ac2c0c492301b87934
+x: bf2526af70bc55f0cdd4c5c5617bdedb4f44fc56ca6f2604dd080537
+y: b392c76b3ae14a2caa6af7553007a57ac21ef60c44797ac1c13ef68904df8b072cb32d0dbe10b2524243cdcabfb8e19ab31e82d693706f953bf29453325993b7278c7e99c09a666760b1ce5dbe36b56cc8c80a0e85a972f4c0076bcc0d349d3c17ee4b7d0e8257eb5aba5a4375929a0b4f4edc350f268c164e6eb204847bf24d23aa072c6596b2022fb48773f8538e3f85aa433e88330b302848a6ebf8f0afac665c98bb7b58ff11753babae22e0974f257bf4b6d00b87cff9e978a65a86cccd593f4c3d42b78142009ac8bf077f69b38a4eeef9c2d425406d06127135e6f5811e4f22f6da9dfd18e24cf8e589c7cc3591dd995e5eef7b07e38b3c99ae7bab9b
+g: bbe02d890fd97e0b6b84d07e2e6a849378e01a3d2f78dd32b4cf0b80b51af9565048bf7c1e55512c46e41fb4f52623b95dae011567451235db9e216f6eae605951b19f932cbe98784e5a1b5c74b8efb554de8d155e07aecdecdb6e2a29c8a67700b70a941809e0e84053ee10464f947225040dc3e4294277af421e664ec90ee63779edba49f71ebb3aa40ddb1138bbf869c93bb135b5399b72b18f6c8127b114f80f1d331004718d53d3c959b927c5e8b50e54b48b78353ca2835032c10eab92930475d2b2cf7dc3b0f903935a6ae1dcce248df90ac993b7674b3847319deceb1e13edbeb32c4d126bc62c95d942a9227bb3b1c5fa7323c86d83499644908ec3
+h: 180
+m: c30aad0e2009b9dae759b38e15f48dbb960264b6d3836c7b28d1f31a84bc9416c9001e5e8f2dc6c5974141af76ed35c1e23bb852faaba5d4319c695d1beef19eb151279cd1d2b3ced4a9a6c921c044d4e4fcc31a168c557b13a8aeab47906da64e6dd3e80126690fc5633dd295c71e6208a096d8ffba2e0a5aa84078df1b0c639cf450aa02dde48fea0ba367d82764a248f4608bc8a2c9301ef3721d7f81b84b19cf11d4aa386254cc061ded39e180a7a3fbdd722b3c3d02ba1a5e682b68c34ae2c122477ca9d65b91530e94374538d824429bc1bce58f8bbf744403359abb96704d61cccb
+p: fe8dee38db57a3da152612c5e8ada96f1a39ad0788a40cd2f72c338d37a04fd4698b4481e5040853d525c54810462deadcb9b9f11887124fe23de852aec93c36310e22b5ddc05bc0d713dd48f76e51bdc7606d764aa5e9d2413c894083452ddc395893ad576c018d17256c504251674231b045f818becbfa353ec82ebf7c88cc611e0c5998967ea2823eb3c14bcfc2eb642f40d390301ffc136fa30f79384064430ebbf437af76e8a1510f75b1e11490c5a4763a0bc10b73b61a21682266c2808c5d644a77ee9fe86dc450c41bb641eb3ec0f79ac9440d808b9abe69820fa7f4864b51d3c8b94041f37842abcc0cab94d24e84cc42a7f387c7dd9a2ac7e0ab11
+q: afbcd117bc0e36ff2af98973b0d3b04ba4f9a3564bc7df9070c53b2b
+r: 1aafdbdbfcd3e4264f01ff233fe2d5dc15b9ec922168e41eab6c6cf1
+s: 9de80ab7cd1c95764ff830afbe573dce6768d82e67b76dae3229e1ae
+x: 5beb69e84cafc3d551c6bde8fc4d41d535f486ff6ccbc16c0f33ff12
+y: ae80b2d7788ef56f55fb81c67c1450a8d8d45ed8aa2b189efaaa6c7110f588f43710281bdd962ae523de629635f2bbc3bfad1f8a32e33380d001b181e2418de0b9909c8aa606428159be928fb7675e9b4eaeb3811de1f4e45fe431adb1241ce12d1430e5f880ee148604c6d88dc4886afd0bd710e523780101b6457158aeafdd1a0e9cdd4b4d29fbe7c2e883df5028ac19243e0a985df90648272ad8cdbfa87bbf1fd10846504459904ab46d977439af6c6154c10e93d15d9e68dac00da025740dcdc414cfb9aee9ab180b451c1a6f025a9d88535afd862ba10f2ef4eb69507cd1c5c80d4fbfb74823176a607e3753de48683bbe4c85d98f3da7fc9e492ad34a
+g: b322f91f4bf16fad978a230d65f8dcc8a0e39c520dd81dc7bf25950a55b4410a413b1122bfbe0370876c511768695840f7427ef9a1c93312c554925aa4b50dd6fa66423c37d77fdece7e143bef37c0dba1e68f426744adcae0e9986e23caadf6a169d95adfaeba9ff69aa9710880ff429d7276fe0078ff2e1735edfdce49534a1fdbf624f973233948241d6139863860b10494ae957d8851dd200c64700d1dddeae72fbf14f5f6bfb0e885a0d9360671da190b22d315792232fc12e838fb0b4f901683e53c63ded5ab16198bb9f2671af9f9eab257baf9003de12681e900ff1182d80c69b37e9a9ab674dd48dc88f7020e0f083413ed8f6d35ab0e7cd86fcfb3
+h: 200
+m: eaa0c500986377044edb3f4afb03024b822f7646c2ef120b241afcb2f0aa8c1f673b9835f32c6f6f0f873b014fc3628b16c8df27775a4654d655b6f2f165eba548df892b0201e456e170aa3989b45c9dba81bc8851d00a19319414dbdcf776ac266cd3b3d07940c74ba7be7441c7227c15f7fbd8ee3fbbec97d5aef6ac640df79bec411acde25cca580d680573ac4d
+p: da26211e21a3cd01bbd7fdb4d7a2c71712f1398050c6b2c3633f4f62b5bc88f7013140ddc4b8de7b86e4f85fc522efa9a0198d441610c4674f1b4e5cfda073307db97e917ca1274d588580d1a64eb31a50ba2c41846bb7f4d92b302bf312d206a5b7bab44375b09542647edf8d52b906442a21483ef2aff95357e8ecbb3b234b06f23b93a5e8a6aada365b366c24aadeb209a652c60989c3b35841a45aabba63de76dc482cc800f11539862611d375ae94f41431cd80432aa1cf066fea31ce4d313cb7023724b05f30e85089c105d9044a3d4eafbb9b0db2eb51d3d34b587063d98047972d9110f599a0a0cf636f1491b1e07bf937fc16e40e4143dae60deacb
+q: f86719d2d44c3467f241aaffe1a77be6c2cec7cdf40852e724bd681b
+r: 93d3607d57db2c3b09a6656903a3ecf92f763568b11db2db5a2e896f
+s: 64158980a59418ede8146033cfa5cbf4381fc1f28cdc0bffc398f117
+x: 4556f150c46a5156772f243ea7fdd1cfb40141facf27cd8cb8ebcf23
+y: 7cc71c7a2b578283f858bfc158588811312600ca6224a86cc7d3911706aabf146044ac8243e42d2c1cc32b2b0771417e452eb4ca9f15aa4d6df1c45124097a9df3d9a3ce9f5e89c2b7e8caf02cb0a083e0b5332b75ad69ff097615fefe1b7aed604dd7b59b770779c6a3fcbd61b5598d122255d8ad67629dc44991fbb30e59727a3bbe6e53084b836dfe91a9dd03a447d0ecce13aabd6b498127a023a214b0a522911a353b853f77f202db7fcad1f212a1a9cfb3cc5be885d29740e19ae9d73f6e9873353080b3d35d05f994e592ff0024318b0b09f9798d45f20a815be52c7bbc75a88a348a7b93e19d68bcca5ae1f76171130fe7b09f4288d95b1ff3256912
+g: b301a7e51a6fce40ed388a5a01285ab225dcda486a3fca99be4f1305b98529dad73dc3cdde986b5de3daf925668db5161c0f4f64737086d1db01e7ef6ac5007a553146025314ad69755b3ffb8763b90691519bd3ed85dfdc68b3e610e9db42c04fdec8f371f1f7173d59ef89d58ddb2c8d4c053cbd4e299dd2a973f5d849f3d0717385d3dd0675ebbb93a5ec2cedc3d916caebdff042903c51d4f6671bda8134363f52c8a901dd05551a9da8f4ea83628f9cbbd4d91d66d1f361bf8d8c447a3baf897e27f82e597b27c93ef118f0740601ffba40d4df5496663d55ce5eca53230f6db8bdedfe1a9211714e5faf607aec196be2272132d023f48a1c05695b2efc
+h: 180
+m: d1472adc75c626f4999ffaf2c295c51ce377f0b74b7d10177bf06c85390d6bb805b0d131c0c8c26d1b2a1c23cc77c7f67fceb7fac17ecfa94497e68c028058292ea8b25039df56fe51020888dd9b8cadb05d7e66b419a8a2fbd8d424021a1b5d8b80fee95d05d7c7a5af00e3e57af3bf52fd80a21c3aed699b4137388c88b390fde55fe9612f75ab0e25a8d7372c692bf519fb5786aa033b54d9f38c9705eb0db1dd5d0b5efb5b57524855a0b2b591f12456993a849859c74e1f6ef1d653e757825995ca014685c5c92ebbb7de686a685130853c09368281
+p: bf786720318141a69f9196abf3fadc5cca630ff05b175d1f4e0a0784051129b25633b6de6c26547b2eaeae602eb15fe6ef5b5ad1e1d5a12aa65304b6af9f4d947bf56ef2d2e843ce3dae76d3b35abb7b1b6a7fc4618e719ca9cacb9a18e92ce4656ae404445668c299e5334992a49bd43a3a44ef2e312e486cecbed47c6439460937e485cfbc9e00e23c3d894af29ce2e114d1fd1ff567b1d716e879005fee7d6d4dc8f374a62b85c944a0f541bcbb8193ab76831e1b49218d22a52c777e89cccfa25b9da04c7d212ed2bc9bbc982d7dd1f099a6b5126be739c48ee6255d080a74ad8f30bac24d333bb767a4accc47f19e9f2b1e97792a749f92ef701c5452c9
+q: e20001d8ded3f10e26f06163eec1e0fe1f59656874f9477c264bf8f9
+r: 2d5582712a96dbda319d8c5c5c12927b891d66530d94563ca1c9cc69
+s: ac197e0fce92a336c24313c6ee013d5d3c36a89716b783fb3218ccd4
+x: 692bc821f47bc5a063f77c8323a7e41923749a924dcc454f9f086e5
+y: 7c1c48a6db0c8f6eec09310c4c44d5816bb76d24cfb305f881b1ec637b1355155b7d40dda0f234b9ade1587be34127416b80a5de69b47580d42579fd0accb81f1b34449124d57ba4d6876a35916eb6d7e3470a3ee36b3b7018751c33b890edbec3f338956edca04bab21513890efc09e284644bc2b6dbfa70232f876b8768e00d58971fafc38a56d072fb633a9f74f3905d00d01d9185f6bafcebf5f40bbb7c9eaf1e941c72a265bd27191cb28e9364fdc76e50a9ab036f5975405f95f88a9ad70dc22514dca36fa3836feba2694712a9acdad031ef7e23d3d177b704ec02c196d9bef4cc7397a59c2e76a0e1a0520e66b89ecfcc93fe635bc357f9147b47eb
+g: 3ed7b80b330ace5d9272c0b02e3bf48a3c836a2cd16178df6556dd8be938cbed1504087ea103bb32b789a4d807cf584921d387aede92294a05a8e6d76875852aa11867ce9a776f90c626db3c003c482ef1c1871832bd240f7824d6f1fbb51966e694e8cbd31f6b4d0ecd9adab5eabf1c51025fd5f8bdc51094b0325e54cf3ec4038622e394734e1c5ac57307ad1a4546d0ba043199ad9d2a1349bfcc8009102bdfa42d750473a229ebcdd83d5d165366f187f9ed7b134560edea5d414b2559dcb2d445c1e27792261eb45016987fd609b25221b30efff4020f60e7d39e546dfce4fdc56bae6c9b4b8d0c1ce684ac3ce70f951fa571e7a3b4700d6ec4bbf6e9ab
+h: 100
+m: ce6d8744756d63c0536cad533393cd50fdbd7c563849989f1bc1ddf42c04078558f906f17e934581a4609a501514e1c083ea4112c594a140759c7a7b09e77db62b3cbacae1f1554f245a59dc336a552eb7ad332a11a854f2dcc7375cb1f3e970049c28b30f8a9b7666386dad70be068633abf6168a4962c40ec6ae8e0b74ce472b4b45209e3a91eb7740a306ab352c8eefc23bd09712843c8e3ebf045b4413788352a7bc9bfa6c6155790eb7df94dc4e3f7933e70120fbfae2c6d9eca41074ca5e155f496ae2237b092bad5936dc3aa8e41c49151b11e14dfd89fc1a5cb8f5b1b9abc1e5d99780168a12a77b0af089b3bd69241b4e
+p: d2b2da2141a925888d0a1f06a1deee7f912b362007a9a2f8b7c1af2b80a7223522dd2078f6a20ca962054272a33f10ecdf20d92e7756c2b41da66e3b82b7b04657835160dab105c299e51bb3863c37be75e4320ce6e3e73cc122fcf38beccc52bc0b59da29fe28125da6c6618d96998463edef232441cf19c089add3a376e2803c7ce000d88ee4e7c048fb95a3d0dbd41ff20064441505953e8dffecd9d9167829205603de5442d23880efc5322324d17d91a53ce0c2f3da567b852c4b00ff0042d67a78e3890177a717627d4a8cc2829bcb1fd6ff8a25b4029c00a47511fb58bac6deac28d3188e1032478e364b9f74df9e49c01b6780b7b06b1e074d153afd
+q: d5f829f40008fcd9e3ef888dd1b47f0100ca2e68fa12002e5be92f27
+r: 2e6f4720336fe39ae486e5813bbb7c66bd0bc27ce90f1e3bae64d0cd
+s: 1b9d7e3b00f021ec8cdaa94303655d95a1bac1267d1f42653439862
+x: 298ff401ff461420c3a43e2ea18e1271a77b58fb59e4340d2f532c08
+y: c533ac2fb59e1d1827537c70833fc65625fd813c121e89ab2154d8965dcf07997fe6f86000bf26bdb5fed5df4c751a49397272bf140093decfc9935afc39f38c3a21fe59a8e6f918b606208116af3f996eada0c02babf8f3ab74fd7bc8d186432715ff8d8ac1591fc61c6ceee3452e77efc8befe1dc9abb5c77306889a45072d3efd63d4395d411785d1993275c90ce481abca8fd8b68b9b47ef37e58dc66d3acfbc214df4e21a8d42fb01d58aaefc40cb0bdbd102f00735f0dcd3b0b7c980d8fd91d59ddd9e42e0ad49afe275ea55c2a9180b747e6bd6ff6abca0dfe521d30058e310486ac9901e8c6c71c3b1be166380ee1534cd5e804e1b963c5c2fed59bc
+g: 40c4edfcd24c5ab77ff763759835ae547b4bb1f6ef41b709a5de195bb1beab3488b5082d0b15f4a23adb8008f743ec585386ca97ffd16275332ba3f7150ca0ec2af66f1ba6deb1467c526d376dbf6f3e90d7517ce61de1299814b346e72f581cf89fd14d3a4240296efc3d403058f07586c2a4b9eed2861697bc58986e26206b7528b9a05c1a5f71ec3e52bab752fb439501ac1128f554026e48fd4d92c6007c214a373a94a0918d1a0ca5afe52006e762dccbcaf3890fc2d98d2f640eca079b222ca7f6caeeaf47265f068f83c73c9cbe4e7071d9d22c6b071c038fa727b1a26e3b34a4edb84353adb37645c1cba2dfeaf4077de8ebf2100e7222dbac9c0cc4
+h: 100
+m: 615978ae7e80086e3f99c5537e3604589a6d832243e6223148d286360090e517a8387060d93743a47ccecc5ab25ed9edf9fbc0e68c3e3a54b69a36bf4d7aaee138dd0f9ab45b2b0eadca4c78f826e86732aff3dc4d68d0f737c0bd6e246b503cf0ebe83f9637788de9d46e4932d1b1a21eda9d9bdb65d98ba7a1df04db2acfa57297ad229ab578fa865d93c93bb4de128be2e671fb7a6c062c29cb6a17281b4f7d1a2889646ff6113c0d896f2ab9c1
+p: d205003f44c6c0f33b299b4eb8a05b3506f512778f4d837f8bdd3f408a783a55d674630761d0881ba5b61a6cac40ac55f3e73bc01196660880661b834c59f9614b20c872a9aafcf867078b7487d688335803cd581622b829d39fb9b807086dc30016abd7d612c815ada6a98a5dfcf3f09812edc578d6d36e2b34d83fb478a1afaa9b6a542ec519b3ff8efc85b43326f95b2da6c35b999ee1c7616ae85b4cc1bffef17bc44bcbe78f38a312247d8437f49ec001c8beea62f77eb512731e9a02835a99c207845497939f7169d8d61486c910f00410553a6ecfa11860d4a6d7b2c1d01390d5fb70bca57cc047caa3fc42fbd90149d87e0827903568030b398a2d4d
+q: ccb1cd1fb6c4ede3d65f0a2cefca3d507a5f2ce43f1e9716421509d9
+r: 88373ba66c99e37e053832396efc6d26f604fd835e859e8b8f1f4b53
+s: aba32b5d785478ac6722dd52c0ef3ff945a4ea28a53553f8c3050bcc
+x: 89d4394c0b9741544e300d51c0544f6d751f4b9914b9a5681330547e
+y: 5a5cac7d833e331ef7e41f5017a869a24b8760e19a4e75a33ad593b2951258f784879c17bfc0071234f5014eab40b34ea195f60b2cd772d2acaa7796a5e4b30e33947b77e9616f6d016363c9c6d2e5019aabe854a7b29e837c6f5cf6af56f44fbc0ab08bc8b015f6291fd74a54f8691a8b2efdeb4a9756864d3376ce53431d6cb41082f569c2efb417674fa6ced28c21f34dac9e07f17858945834eaa4b98935c9583eb2e7354b978f18c414fdecdac6960c6c553bdaacbb97772709a1f3d61ca5841f367d570a7c59aa73cd26c891da647a4774589cabc211b6a75eef6494f63c83285b8ffd559806a6e2205498f54599eb055d9d62dbd8a4b71d777e3f0c61
+g: 1a0913bfe15eb8cd01fcfece7bc6222835b11f5aa4fe9ea24e7fb15ab6836e15ed2c2b6d5920538579e08059df747626b019e5ca60440e73e1ce18a15b72d8a6698d479ad302113e79bfd8bd60d0b517db8aa1af230462a7fb5d14600d5aee7d4fb54028a1a21a51e0ab8859c6e6782445c0f0d8d9581579c81393c149c6a198709ffb83a0ac817bf883f6b2be6a349f7741f6c028b99f047a879fc9c16b03619f0af79e2150a6b9eb9873bb5ceea4ee9e5e6a0bae553f7f7df1b8706bba77761fcc60f575d3000610c46560a89c774678a2e66f2fed58f90509036124537277dce03c1c31b55dd72ca2992751f1f356c9a6430e8866459b41b2575d1b0e347f
+h: e0
+m: 821fc31ce0dae4e3
+p: f75345e63e5ac46ba3d1cf9e7bcf1294cc811b3b1e92f6621165898f6e9592bc755de3fea50229a2fa619c813d5889d15579b04d85711128706bb730e60766e2e684d4b3da3f0849ae170954f27fe19caaf6772d5e7d5ed13abbd894f538b87d59c9a330ab617b70bbd56390cb5837f9fe2687a4f148f444e917c33d57285b91aaed34954ff2c66eeeaa77776e5fe40efd769f738a597f5b6199d536cbcd0f681b73ed378d3e3a79f37c58076cb0af67b0c361999d1e19a388904583f32110fc69df0f2595823391a07521e17bd2fadbfba400d366ed5553aa81f6da55b48d77d6737e192420dcc292bf62820507fe48a7df8f9918d6d974089741220d42a345
+q: c409444821c410f31492725974f63e177891085b5d7865c5833a2cd3
+r: b96498bf7944f31cd2a0c9b7a9b4bf1b0ede948c6b2606b2fbc06f74
+s: 303b83241abedc19eaf0675f138d0379baa6c67e8429a4741f90a60a
+x: 8c80c4b4a8ef2ebe319d16a1406845e9e88bd3c9c4b400d4b4bc130f
+y: 1b156194a993ea73964f56d1a0f4b79266f3e3fb033dd074e18812ed29cf5d9f88b192a06a7aff2a135cf2c2ed3f14cd82813beb05771a69d62b0444938e6b7e0091ba8e992ee03ad0553616928ea5f7ec39f2952b6d75cebd0834d9ae22b30c491b1507378fc99b55488292a6deef73493641a8447789e123f12a4011a176814f24348acc96858714be6d6c461c02dfb45449ccb7096146d721b8f2ad341dae63f1c3fa3e9eb6a9e10c69a3cbc6c98bddb5bb4c5e1e005627c87ffc0685d30580276a81ea7e8fb745dc92f71574c5b50602ba73b4d1e6ea8969aaed52b76e2f875fc103fd54900caf319456336242247f233ae8eef3c7abd9356369a6c36d03
+g: 84bb8c33660c6d36ce2fd5db0125f77599d1d1ed8a3c20be3e184182ce7e46744c6243239f897d9e41ca28ddeb3a94996871fb8fd3c20090349acf67eea6e94d40f645a255f05229ba32b67e496c327323b509c8f278e5efe79c1118e354b971678afe22121e0c4be8c6e40415215cb7f42703da5c34e0881b1521b3c8e53c3a23087b63887bf7cb5e0ece56728485e6afc771d83974505eb239e23161129ccc0a0b979cac98003070119dae49216cf216dcd08a7d1802642576b738165d2198d205a09eba54b05d8ec20a2e7ade599252bc3b315e8cdbbbe881b447ad5ee45934808b47ebe09e7a9febcb07b2520d573b1ec1a858ef2886079769d6b0d0e0d
+h: 200
+m: 6d8a6406ed2b5658742a0087802a31d51b54b4b453177d8b031ab226d5a1ea321db5775ab140870ffdfb54a1c72ad5e1a194c7f76a7a1379eba1ba6d587964099dfb463dc5342329f880b570f7578ad30040942c7ca507ffb6d1240c7caa3cf4489ac76cfb5e972d8fc94f60d14e55d9dc71f87d0d99f3bd7e3d1a423605637afe186e95cbe2eb6068d3df
+p: 9c4e42fb45b8b66264a843691c88044e4eb65414fd174adad0c7e866d550195209438a54bda2260a0c86a619d2d02bd9cc09da948b9f8779106850151a16103389fa2649878bd1d615138e8aa7c215721e84ff2cc819f534bb8fa026904d2d84821bf0731ab2106de914d4a2d17438606aa10016cc5eb3597b75cc43fffdb6360d9df891d05354d5429ec84c87ff5d51976c6c9559fd0e21dae49a7f131d703e18c0369c6aa87a4585f5aee1726d4829d8433d2a1d9c745c47befadc1bdc7a12c3aba473becf22d460d38070eb9dc8d644575efd2066902dc9a516d688e113e595338f5104129910d99804ba882718f1cbff057833188a477c611c14eb0b10b7
+q: 95ebe86036220d7015467eb80d34a5c59715693658290ef9ce880c31
+r: 5224fa6e33f8c977a985680abe9fc6a1bfdc18f54013e9dd5dc56366
+s: 733561a1612c23abcaeae3d986742fa8d38c1b74cbb2b15ce20047f8
+x: 936969f28045210777ce40c6b0e06f3917d806498528fb972a1652b0
+y: 2ae2fe2d77f70bb36f135f84cc1bd1b2b81bf1c18278d87190b0255fae2d342ff6cdda577ccc609d6c6ae1e3a8394525c562ba2fc303ff133fcf4e3c33a56c58d0553e3511a16e172235f99437b3e31f519e6b2d68a70985d2af462fe454f83e9cb5bdf639bf3b83532d731627dba60a5cea01ef45d4d7905930dc9a2b2e68599227d7156aa45ea9d1d28ffd88f0ab7c82acdb13dbebb02f83e6ede89c68843238bc77f7cd3598506df71426b5be6db4b86f6dada3c30dff841a3394e8b8a45cc349dcfb076d17347e9198732c0e066f670bb95f663a8d2a920dca2a067e7b4d84e8b805922767ba58af3187d674dc90c7615ce7c7185f7fcbfc13aab1f56e00
+g: a516a43b28074552dccac76e1f9153ef5d979d400d51a16ddc41b659724aa0c577c3f44675792fdd0c0c85d42e808fd2403b4dccf3771224832ba8c4ff9ba5e60cdf5190260e1b7359fe940d711dfc6346fb273c645b6ede5872852bb9f0cee715ba3f2fcb77c1ce93a3c6a5d1b2a1ccf1007741fe13d8ca843c959f159382a1ece5b6784153dbd07853040964b6f7b6336636af10aba97e9f2bac124dec3be6dc8cf6d8e1382103bd4a16840750b87ec4f2bec8a3e9c9bb675f8fb7312a7ce2619f677324b27ec739601c9fe34f7d5f91c05840b9a35f79e7ba51ca93c2e226ca562f8d042d8fe12301cc2299bd9cd2cdac33990d3fda9a4e671071ac77a001
+h: e0
+m: e3aab0b8b862384bec053ccb80710e28ae003c7a32cc37eada858f9595d5362af48c64e444c6fca3c9a45e779cfdb3e28a248e4eedd38972347a586ab62e93ac61d6d9b847d84267dad39a1f694acdf85a2f372b4a024b72d446220f1d18beb5b01e6758ad6f1bd017cfa23b6703692576783ed4ca094ee1cd29bded021d793e256502be78f22ae35a58631629f578d6770d87d3963b7530dbda49f6ca6c2de3183d4359d0494e3778c84ffac9f9ca8e76d4a0045c68bc21c87aaa6463d9de4b43397f26116b6c5b1d8331fc2bb7c7dc
+p: cd8cc07f21148cbf3cad498b37263bd63f8e6d446502fb6c84ced77f2007df2cb6451d6797718ee077234f7f02e5d0ee39c55d1cb4748ba501b35a1cbf468a40d782a6717b7bd627a8d5ede3ddedb16b29f29b45b88a3b92c879e97b26c085ea1409b857ae94269d859424d748575433015e8a86aa9621712667cb972570a090a687db7b24df02295ce432ee6d59fc3d6358a01d5322d52266b23d6e467b958f2bf0c5191d9669c024d9289f67803b07f169f8451c4ccd5910f0da3e781dafb679ab39d9ee914c61c38930f82c34eebef1fa38ab29fc5ea71bfa9423f0370ace21ba1d3fe045b1d5332ac5526935862876a100972cb3703bedccd68d772e3221
+q: efb3a7833360b01d1b6c3cabe3bb2e9ac22912ea4a186f9f424a5b41
+r: b01ea3ef5bd2ca0d14917c65457b8575f2f99a34396be7a5ad3f7bdf
+s: 17ff9400f24a467e9759978f67236f9933e69ca3762801dcc55aa35c
+x: 5c8033b048dc52b7129f12c003025b2e72a8625478457c279fc72b91
+y: 76190c3ec95dab6fade064480e2d71795c4b9cee8628a003da18d823a4bb69c6b0506ba492f15096a84839190e4732b9cd667726a5fcf8e619d4766a4cfc2f42f5fbd5ea35170d75328b394d06ba6ec5085b88aa331932f9800ccd2cbb295f79492453285647df30861c750b02b7439044ac1c3e3a516a965fb8e516e60082ba7bf23121e52b2fc40967a2db888ba11e299ee2d4f1d4a3ffbd44818bbd19011e667e8c7d817f9e72dbf448eda75fca44581fae7c54c624f8fc169d8ad0a2458f15aeafaf8c54c5ee77a8e60839fe6ef03ce3f32cdb9f9f5e66645e470f78cfb8d28f8b23b7ba49c2f774f0dc4fdde6602b59dfb5a45087f6ef820d03cee2606d
+g: 43ed94755abe2c8cfb5a7a2a0af3914721d9f9471023a6214c849a1c6f7bac2efff355edeae224cd974b6e79191f807e533e9347e8b5ccefb771cf40bb32b003fc23f4e41f8f1243dc481aeabf22acd96ee06a12224fc96474fb0f1f789e302d55b50943b69afd3d4d9687cc0143f8ba4c9265cc134752e3dcccd362278f130e8a43e05d5ba81827e46d5dd5d0a186111cad85d5869dc07c7f9f2d6a7ca38817d266716f8b5b31f7b3afdd20f2151ca66b9a4d8c66a0ccd8bfc8347545cb6f05a55d98e1608a36c2d6c45352920d0d769801583bdbb30bf227bf19547d56ecd1749436256b80680b831a0f7513c6a2d21191e3169219bcb8b1cfb7d587ce2383
+h: 200
+m: 0b3a2b159eb6b90a85487db0e86ef3e48c40221733a5c1e9a74c00b4ece451affdb56fa94bf3453d613c63e507009e4c93b4246fac
+p: a39b9105d21606a6964fea76245e06e866e3924be90c95b7e848aab7f9f7f84241263f336cf31006c191d0a9e0712618fac04444bbb1dd090e0ad8ceafeb6c158094065d0bf0c838d33edc29d01adba3dfbd0cd86a465c6d9fab724b7587cbc133a0ebaa4bffe09cf7d872a77445694cc16ace3b1c56956ef765e48c327d79d3628410e46bb378be087ab8b5dc3897ada29826d0d334495f1eb9a504b835f4c98d66c1870998fe8d0a96194efc5b42057aa6f09fe024a92a237f10414f5942f5a84dab005531731fb67ae0e056e7ccb357c3b4b7b93876572d35d7e8c02d5952e500ad60cd5992eba41e75f10bfa56a2273397374d8c0704e567c4268c3b770b
+q: b00dd8e0d21e3e4561797f7edfa87c111a06a6a6e94f249d108f99d9
+r: 649654fd6d60871ae2ce2dcc75471c88aef5aca3e4d5910ff77aca19
+s: a2f15deea9d7940080ee2ecfa65b62c42e953d37891a53c1cff171d3
+x: a28fce73421fcc0ea92950e6a4c319d89e223e73a441f5d1afde8041
+y: fed9a6a1c234c8fab3c8de87090be7ed462a34d1e97edf180f31ea264f9defc61e004cf5b5ed4a72e3cce449cb8993de1e26ce3bb9c849ad63f93a31a4ae2c7f49b137d44933fe1dbd26feaf5e3b3289dcb1885e2115950bdb2c6d7b0d05dbc6b77f7f1c8cde0f0e7bfa2135343cceda1013ecd93b4f774e5efd4085223a8871077f1ef1625079a08fa8e99d562c9bfa8dd60c8e689a84c071c2528e64608e6b9faab20ec327542d57ec66f093624a24a7a493715c62f1bde8a87b939fbab8c90eb42bb50ca6a652bd554d797ef54cb23b045af41d24ff1513514874d799a1da05fac75d6219b274e969c5d37ae5de5d6724025addcdceade19550ba751ba94
+g: 51728bca97842ba96e2d8e4128ac60faa009adae876c0122f63165dee396adb692d1b7b65b95aabcf06bdc259c1a630a0ea9baf80ad3d4f7faa91e3aa1a30d00c762068efd4f5b75c4331121209d06a3eeede04c5ec5a28208fbdc309f86c85f11da215cb727cf88eee1cec488ae4e927724034f08b2d3cb942292072770bd2d26e160b12811181259ea160d55181e17a84a69d5bdb31b415dcd50b65f28831fde054f069402056af102dbd06fecbfc85413aac7a642ea3802eab302e1f5e86f294f2fab8735bf6ee434e2ccf7524a34c4d9f23ba323ecb5722a0fd334a4276c8482e8e0a5d773598f84f3b1359bfdefbf24f190edbfcec192843a4dd8957fac
+h: 100
+m: 850d1ff994cb6b6b3fad94bddfcc95a5fbc6e659a64b24d129af6bf80c3e13486a7a0d230542e4df16971eac2ac131de337143af186a2494fd91111b61a6dd467616d0b753d351956cae81a59e53fa8056eb7f5c899cdaf9ef5b57f340bd14be57fb801934aedec0460252f568edccf751bf1905e158c45772c5098905edacd761f9bed68389f25661f320020542caa70a08036b3e0bceee57d119be9fe96fa1b9a8315a730187f77e061a0f76a5fbb833284e4bce9ce0d81d68590c21025d7a5a7f205b43505743eb7634fb7c35105fac77974ac269f56962208ea34426714c24
+p: cdbb297cb234931ac0686b17834760cf7525a46553f7c4553ee55e47ef35edabaf2cfd5133ded833cd86629cbda0d8d545d38baad4432469d977a9287cd1c9cbc2d17802ec65ddaf7042d0399efdf17804fad10fdd41fc82b3d73d5228fa47d296c37f78b3bd657618c3220530c62b02a19eab1d414b1a42bf0781627946094ffa8890d3b620abeecc762eefc30383be9602faab66fe53e542ec79c3e55f3c7f4771c2b0017040c44aeae537448cb59e7873e9336f295bf0a109a0bb21f021f140a35bb63fb04d193c148a05bca25a2676b137819b19c80b7d3b4ba41c5cdd81cf99ae7b4e623d49ca86ba7b3a899bac79a5467a613130eef2260cac02e6ff13
+q: ceb64adbc91e079d692bca8aad942bd126191359d7fe7a91158033cd
+r: 4ddcd99af2b5ebca3f13adcc9edba0ef541a14ec7bedb2faeaae1dd6
+s: 317b3a61d6ec00a59319d9f1fa948d79143c857261f7a227b83f3eea
+x: 6d76dcce94dc2c941040f3244fee951fef92cd3f7af31097a426bb3c
+y: 9a4e23beab8376d1e41ceba731e11046f0dd77bea7b6ce5f21beb04153a7f0fa86c2cd1feea941e3afb0c326262ce24489022bb971ebdf8f12ca572ee0f1a9130be4fe8c57a89d621a19cb9723bf3789f0f909000148e87f673374752d40e60e595e1e4942dfadee7441234ea027ec98c6f67c6049f6818141f7ba68eb60e14b48b6adf15354e77bf8e0f8c9389492976889dcb228163fd57a65015574843074cbb8b205f3f49dba417fb736157ddaa2c56dd0e923a449bba48a5c8f1a6880c730ad51bed9a4b0651bf4199baa4c987d3fcf2c94bfe12a8bcb6fdf6f620ba03b3beee6b19eb96410602e66625348dc00664deb0586fac30fc48194b07944dc41
+g: 31a2ab38476ccb2f6eb3b64c1b0e532d8c7c8062d718733291693d8c8768cd1b5f76ea56200172b8d841f2050a269b1bb6e833e888f01ff8fc097e1a123a8f8183243932ebedd7ef172cc9a9ba8b5581b06a543eed38da4ef16ec24ac3d0c12de6befa81a1940255f5a15d8a8615a9e7076d4fccc906ee92162922ee1230c6008a279ceabb2cbb28b1b167f46d9a4453715b9dfaa8e0beab255da1f52945f48d804b1edf8d06327c9b04b27772e296cfd18eab97f49ea2ad123cb0cce5f4765014bc334dfaef88782494cc6880d82e24d0825b7fbd600e1b2af44736563adb1168c304ad933f697d1466f7f3bfd8c4e63553c0c4e2310ef10f752b25a894e29e
+h: e0
+m: 0438a49c64636ea5d0a973b8887cde32f7354252397af4dd128543a60f81805f65b23374f0c4345be504d81d4ab442237fec6217ea5cbf809872fb1fab65fea6f72e270eabe7ab1ce52568762cf0a088a08120e5d9fab8f9a10bb5475fca1631af4082828c872d800e989ebc8107bf9c290fc8fddbe9deae4a6cbea6a943184c2664ead668d6266ac7962f774e171ebbc7dfb7
+p: c11efc9e92d6f52c1223473d1ec2a024dae661bbf3671dee10229268824723f801598ff46da0fe8a67853d1ded0fd4bff692c111c0971f7128bab01872d18e4c1c69fe5d5c066d3fb91f3b75c8e3ac25fc1d5725eda726edb0080b464b557920faade45d226bc588d0d8048e4e643ce163147efad703129f9ecad4c843ca2f39a86db736ba3cfa7aae4d5a25482c8dab7479460c466565871c60d356f60e7992c761266009b15f1729df20cca35eb35a5505dfe6782429fec5a3138b02711053d9f36c99b00547e03e9aafa59f902e33a5dbcc96c1a74e5d7bf5fc41cf73bfa2b8887440bd487a969ba808d03483174862e2b91d0f1eb69b5ed38a5fd897dd0d
+q: dcde01be27ac72bedbe45d5c8c5817d17bf41a3a612d622eaf88f4f7
+r: 99fc764590fed1f37bc460cf7ab72f93dfe0ec3e439f21847d69b7b
+s: b7158ad06fb21622f2b3957af17621f66ef9fc324891e61e230e46d
+x: c38f89dbab151c633a3c9c71dddc3ecfb540aa47d2943a2cca779182
+y: 2be5f3ca9c02f0e12abc0e35e82365490db715cd323f4e11f29f2f02b6a5ebdf67148bbec6ea6f18ef3356b57592e952de91851054aa03d9202c7680eb9594aec883cf1dd9a534a8d18eb428b9c9b9d95cd9433f990178d36914a36d266f67a7546cda5a66450edc1d3e4850e92ddc17438b051c0bbb39e42db129429c4ac78a721fe059203e67afec5092c032fe2d317154a9bfb01b08eb8754495a6462fe9944df64561cb21767255eb9fdc393d3cbd5122a2f534c1f921eea32f0b92925ac57080baa0228c31878d102db179a77a7571b491522ba7234484c3a232dd7ec7415c16a914cc4364276c412769e0a0acaf2c6f752821abcff332b09f3c79a5962
+g: 6dea6eba7f8a25170379af7457c383fb149e35e47cf0b7ef00a185e02a4f07556aaf29a20cf5fe7fe6d60d37e24abf325ed0f99ebc7644e23f87f96a09a1b9b1aca3ddccf598ba99ea0ce793ba861eaf54058cc2606e49fe30d5f6d9c9ff7cd132f55077dcb7f7739e893dc290de96d2886f4bfe5ce546f61096e38555f9849c8048db57277893884d176446c14db61b7697a03aad87f60b69c8d4a7ca1e105301bd28a39b4364db169403c2fd3d6a159f08089e5e33bceb77de87a2e613bdf6808df07c7bc15b55ccc6646eb48edf075334df188b22744ebeaf0aa0a5194b4406f6086d5f17cbf7331fd88fe392f7648d9d87d0da60cc1d0f2b217ceb70aab0
+h: 200
+m: 1d67d5f4ddaa362edc4caec3a5c441dd123459232fd09fefde1c2d65e8eb5e00f0bcb407be753042ace8611370b9b7e1f921cabd75e63760f35e3f16852350477fe6ee6452383eff37a9be64231e0cdcf112b29d457546316139aa8d831d2663d52b7ee3b4
+p: f2d27bf9ee65d7d4e54ed3cf58d38a655b28f16ef30eff178c1d63440dcb375d7530fb079482278fe1ba99f5a65190bf4bf373ca7b8468e3f89b55833ab75c6d17813daa7a5df5f1d24786312d53b17b44eef8f394b32f726bf7e620b96d84e9dff62b6452cbfcc7eb4f830dc03b9fc8949b2f586565dc4cf71f5822666dc9b9c66c18559fd908080b1be74738cb9a2ab619576d1329e8f863849fbc87156073419146f03babb6da725497aa1403fd20e83a137344c733cc7cf82af2e1dfc02ca649352682872475174cf79fe9eea2ffebc9cf91eedcb3cdc038f5552cce2532c2954998595bf6dead1a000935ea51f0514990c216e16e49ea8522e7ccd371a3
+q: 8f3ec33c9b84d3452621cb9d7cfbc3df044df429299b23f23b8e59f9
+r: 12e1a00a35642a20c0bec8af8f075fc5792a906e066ac436cbbdaad4
+s: 602c1a579a9c24b5d1fc7c7522ceebbc36f2772f9f8beea13e1ad88f
+x: 4d168bf47b3a18053a72f551d47a02b9629762f32e4ac6eca0bc4950
+y: 83cf9fc4f3064f06984e1bec9c141e421b0777a1d146e47c3901d1564edbf41c985f7db9ec4d27de243caecb443f6d5f14e9fd6f39974677f19e2ff8572ce5e9898ae2f15f2e5c0e669d8b75d3bf677941e263d575074515b5acd60fbc3545f1f7f153b040793690423674cfc8b7d2e1e44e22aa2f7b48085f1877099d6fa0420a2bd3b73e7602a1bf68a54b4af09c2e13429b05ef5ff3e16792ff32b0ad820fd9d927a0abb4a131fdcd9b9c8ad4cca9b18fe659651dd0d3b31437332829ca6ff495671ec2f0b759254034e19c85321798dcd728792b268a069c0d88be42e6fef1fe5d00f0a7f07a8d0f5b841d1a5e78b8d093609d92d75d62a6476190379caa
+g: 1a233a1311d4ed1894ac130e51947875b01750e8559ae352a1e2925df29775bb598e9e73e373c12d55bf60c69fc7e4cb72f085ec0f22dc954f79558fcd6e23cd3889d50c5858c776c336485ce23c064a693b15a92ef1c7e5631d3fa5bf0de572f23a0805efc634b143328d922effdba6b4ae76586083445d971c408090d22261f07e4a906b1ebd74fc02d5f875d2b09ec14cc4eedf675dd2f6cd70f8a8e5ca2bfb68a52d9cd8ba756242fe0fbd5a6ec19bd58f962abb12cc7c7b700b56890bfd96f6c798bca23d780ac5147278174ca4ea8dc61ba00909444d23c05ac2ffdabef9bc3ce6ac6990eb4c8d22d3426cdd8e8703a08939df7aaaeebcb127d2afba20
+h: 100
+m: bca5a759104c7bf1340667198ac430f56ff2fcf8e341c04881a950873bd22676e20f3523ffdfe05bb4f74fb28bf5b092f02a507f94fbe0414b7da2fe5add8ef4983253ea7350bca07737c6bed5ab9c0c085886c35825ff6a0d97149c50bade8f2bae5fff05c7e30d510da13de5d298f4c593a4d2a678231efeb8570ea56ede665b5cbf0ebd974bccea51002f42
+p: a2a46c79a457d8822f5092ba2605ad9be9ced623db73758521a23a74121f92dc328029e3fbd0b8771060be15126ba048fc79c1d06fb02af9ecf99a359baac26c3fbc5019699c6c0d5a81e60f9b09ccd8351a088b74bac6a189f9f56e35cb143af878759545abc3e62d2aab675190b3292b72f17059330bf743e30c279d17fe0877fb787506ef0c3e77a83b1a067e1f7e82ebe5cd515de4bd6c31f727e8aae0b8b59c2182450ffb4d995872cf3402ea71ad8de3c08c79625f4aa72d23f9b3338abbf352466d7131acbb025ab6ebdb8c8b3a44d2f22f4e74f2a594d8b7d53e65a4b6388e3c1c6206baa19052ec82126f0e1e43e5dbea84f69e30648aa04a84354b
+q: db78af52026a892f3c8813bb77f0251719d81995a00aefbdcfa25fd3
+r: 63beb195b48d56a156b4a11d63043a2fdd0926285b81f51d842a450d
+s: 3b3e0ebebbbd87f2406d7118fc45eacf88c8b295d59d481ea06afa31
+x: 45323043e71ba5a1302242f9cbf31925c02ed4ff90413747b7a38976
+y: 35a2185762ccda7995ec679bb15855268ee9778abd736b738edc832c4dc7e1026fcd13c8eab3de70e522dbbf6d5ecb5caefd4b06aa60975b116d034f7cced0b0dfaa2b42abf357a6278c5d6e9d40248ff5b76d5b74dbfe99346f1b1abeac9b1f2b19d493ac9445ffd7da5833b0bcd262b7789f48c5d663facd839be120e4af97cf4674b4aaac60e762aadeb748fe4a19bce4c2b5ffadfcdf8a3024e2ef0d05ff795c90c8f17d9b1e8047f5879dfaf7424fe6409c90e4df1103f540eebb5146b96bec7ff20053d3cf454a4a0cbc1b4b1d0cb1d42354b598dd81685f6b6ec5a134c98f055ff124cde48982ad409a752e0f2b3bab03a98c23ae1b12e14395799742
+g: 27ae9217e20e348af00f9cd070a492a1022ab088bd0cf0e1c83e4319dc29ab14784ca175ac2ef81606a41a27226da6d6dbbaf3a15e49d4db564c18ceaada5674424a17e53c6822e722a841036e59e4009c1a1cf27412373bc25da89d7ed7738999b87f5b75367d2750e7fc5535dfdc3bd4d8c9be9448b74eada6a9f476e9fa3aa4ae77e9447c6551a0666760d3541c993ac046be4eb6e3082ab1ea85399c28ca102597a7fbf792f644948f2ea9555cf2aa0b9b08d33215e56b48d1a74e345f747e100731f3375ce9dfeff79a99e92f14dea2b59ada2006498b43e518f942a95920c688e19e59c302003a183b2eff41b9d6bab85ace9da3831fe8341c2609d0d8
+h: 100
+m: eac8000ff33efcc25b977821e86939591a4b76a487a45436432ff8d00bcf851ae54bbcb8659520daf3d7833cf5ebca309b5a4b44e46a4c57d55494c222f7561a5e7a6464ba6797e914961a16ede4298f3993ad7aa91809c956563191766481f1
+p: a00de4c8a703320df711317f490b18c23c9ff09eb809b48df05ef444cbb9f44219e192d3112bef4e4e8be48ac14572cb7fb11c6b51279d25408b77610f05fd5673d9d13988ef65f5f74bdead7144457c5b07969a10576c626a3adb8eb6dce8c3cd244aa69860b40a1632b3d70387894c709a3c9bd93a337f7583da5703a092695f86002568ca29baa2c9c041c0b8f3751865cbc41e71797a3359d23205895a42767f4dd3045834da9192e3f15696c0df1482508bf15d110a8c9a658a73ab17af5dac32e80b92a4883d18126c010465e49167904300f79a4da147939bffb0d1b90b24d9b0a96b39897381d6d0cd0e2075fdf854578bc8f5f60471bb3bb6b77b97
+q: 97c19e3be0291d58aebe99314055cb5f53e9e4f0b2230a517d2fbd3d
+r: 3ac0f707bd12fed87237f1b75ce1cacb8d5fd1705e0e59b2ba187f63
+s: 1af6733e5f495180ba0cf43e0211a8b03587760e352c9bb0bc6a9590
+x: 30ea802a8787cdff6fbbc7f61f436feac394f1e19822e8401c9486cb
+y: 7b3dff0ba27dfba956c88c5a4ba9d2df6f8e1dc30a5388703ebc572768fc2cf4e996f44b5dc48fdf8ea049dbefb003266d138b36f0a43ef04e98881f05665008c740f8bebad81ba71afc7186e367aaf24cb886e0672db2b5361c0e4ab7e56cea50fa1d2d35663defd6c8c54ef3edbc15c5a31ba2203e9c1de9e13068cef5b3d923004fc951b92cf34349b25a2d9e5ed8ccd25fadd87615a5c02a3807c210273c7be717d8a0a3fe4e5b58f8baaea7ab853b4a25e16fa7be9576a2715a2b7828644677bfdbc3b283c3f6bff23ee66becf993c650e1f704513f4e80f5d94df87fb732c32e90a97866df5cbd48bc893573a93c48e6bb409e074f99cb4bb4ca6cbc9
+g: 9a495b8e471a87d5c9c5cce622092d70019ec20ab98a501f74953cdf467177b49ff166ee21eb21f77f50ea69f054fc4d1d2c4facfbfba602f73f52b4524afdf50787dbb658992a5f94d097280ba46ee91344416a300d3e78cef9b0adc33301805cd4b0d21c3367c5564e8d8f1abc07c182346f3f707a531d6b1e51bc9e510db78aa3214e8ffecc8c525f6ab3183e32139413710322c47deb5073156a5e4df31d7890632bc0b568252a141269a8098884d103f48444861aa360daa132e75ad3502ca376aae889cfeab3504d8946e17208d06bcc5e9538b84f7a494cba1fc6ef1a08358c922ebb9f4518b9cb3a816b35b7380e55b3c6af9bb1d51bdac695272de
+h: 180
+m: 2fc99b9bb9831b132e6910eca1353f81bea78bf9d307b2ffe84110439979a0bdc5f94cc79f4319589681bc9be4dea978ab29df7e62cd7f91d12f8e00759b5c2dee743f5dabb5f90f37bbc2ec01abdb05b3f18578063a1bd99d6388a763b8bb391d1c521b681505a39ebec02037250a6e6c467df21997dda5bfa5193c15cde28c329b4dce3a6962b3c2e9a0a0d92eb0901a2a87968c01360af00d72b4e47e3be4fa6ea9debf760af14508368e867e57ffd9405fda3a49ff88501b17cb48147868007d08a60d
+p: d12a0b227544bb19140da6a17bd08bb92d2e716d87da2fb6d6468be922cb77a8d3269c2b10b7970be132c80c041e265a458881de5a007cd2af71197e10b13b20e93e818eaaae88dfa9726d702d1e98b309577065bbe46045f5a6ebcef6d08cd92ef2bda6c61512198bce02a565768c255020a863844a63bd67c8c5b58389089cd22e1fd5fbcb91736e3ddd3474906a7e9d79584aae5a2b01327ff5011fe2aeaf5e697343810304bce55d096c070ab99adc7d0113b6ac13743116ceed5f8edca162dcb3892aaa2ca833802805f781e1c50c88c2d96a1a304b8fe58c3153d9c46608e87e7f1d1e3c29419e4f11f5c5fc38432a3b60637522324efbb455f2d19c57
+q: 9c89242ea3d46e0c33fff758fd61fc10e10dd7bbdc0389730b80446d
+r: 661d9490fcaea9d7c8988c87309d8bbb482c0363859e10e89d0d3fc9
+s: 44b19c3b1c2a2fb43c2a303b59969ea8bed829fa795d3c149c80fe6e
+x: 90f68246c178956ef16e38b44cf3d14105d855c57fde0f3a19f64a15
+y: af53e09f7a5913dc1bc168ee2c230cafd3641a72762b38ac02dde9c4f906b4306e9c062f71e4ae11af2bdfe3c32d0b823e621f2c0bd10b51a815f89f5e1b064dcb9b3a6c2746d5d68bf7ebb0eb17a9ecde0a628775d55e73aba50945c2cad156e71d828143cf618f4d6dea633fc7c14a1ff1dd5a52aeb44041f349adc4ae849213c2f58a9bd4b57eea576e58f6230968bd71455e30efe3efbcffedcca7f6ca9fab26442b8a26d512c3708735d0d3095ab0f3d5ad33d2ab74fe944c3943abcb39ef063737e7e5a6c55dee34cca7ab219712a842683bd87c6529d267393922e62884e1e8a2fe4009f19e962aab7716af368ba10013b0edae8e7e4a5f13f450d141
+g: a45c4bd62a9ed678de9eca6be8ab3b3c55bd7294f74bbea33c11659178b8cdb8be8a7f24f18fc0478be253600f7121f1510ed060aa67ba191d00ed19374402820dda53306265c7b9f2f7932abe8abf63f1d52d13874c4cb2eea8dbcbac0ab463845456cb0b553bc5f999b0691a16815edc863996b651a0c75a63c96df64e4f99efcbfe24df877a9fbfd923cf9b22b0c57f1c43ce7cf751acf5902e65d34752b7514d699ff4e170a52535e9d8620e8016f9f4512e30ff78b4fe9c787452a4fdc362084b86a234b67d14261a17d4bd9e6103a251f1c73f9b7f6d7b2d2a8b29e75c891530ee9e7d8fb1cc0fc2e0ad7f858d991c57d77e7c6a3d03c11e7f6d32d7d3
+h: 200
+m: 4dcc7887a1d36698a64384347cf116edb639a4eb3e93fa379e683ae7bea1cfa58f3b5dd7072ea4906e11a23bb3b919900c756d3f3b533f889a2c2191d5f0f6a86306a76f4ee15fb88c71b55ee4a166e70fbba2a887e7cef2aedade7d9e973a0332d9369a1798e892479e019d02a4399b5de586d291325c17580b879d57e4bb98ce06e5a82bb7842ad79a0af99a97a3c343c9ff01a220db
+p: bc98945b0c9089e7639657668eb67da6a87bf633d7aa6e98db90207475355e4973fd6a2910ac1a5746a086b666fc4dddbf575cee52c4ab3be46caf20ef5750704d2a50facd4bac27fe25d772e69245c375c8b423354d94be4d6c3bd658faefeaada7fb36539d2b7f76ad448ae764ee5e2a5a41452d8ad0dc20cd34ddea6600c5cf98db34136c56a3ed638037f202bf594b8d0bbe2f958a30d22aaaed618ca04ca30c905f6b3ad542b52e9731d389be9453f4c78731e1c09cef13146aedda9868f48fd4db40937e5436292762171dc43e19c031f614ff982b3c13fdda5dfeebb944f28318ae5b571ba60f62b8d465839829aa51c1c1c4e4ecca8d6808e6300593
+q: 8f3d64a23495b4dda79528a3eba43f5b6cd78562a07daab664c46d3d
+r: 1630955a8fe8d976dfa3db20375b3f118df68bab908dbe7e9366df2b
+s: 568053e0bb668c3e1033d1a5304b4fded0ffa1f16d5d240d2788f8b0
+x: 2a7cbabf1e09ea238183d5a286c904b4a65bd623de22de1b66db976b
+y: 109e4953433dab109d4bac0862d2e0fa81ea2be91f64eade5c0bd8b30136e76d73696200110b21b31da0111a54cc497a1a4edb17a7b5b7ae54cf7fc62c980518d8d504976c395720117c70b202ff5f4c3ccf30ace2977337b1189851a480fe13dc01db4ab1aae74f913bd178a08a0f24baeaff9e7e0b3fdbad27b4ed87ed4ce3a7746df7f57dd8461d8e53bd413775804dbd7d469297b383f0eee418145904f4a03b952b81b2bb9888b6e5e804e10bc6617c4b654fe8c7dee3efb0798ef18f6637c880e62f3346500d45f4d4bd9b7145e6304064531327ffb962e884f1075f1bab9ac59a189b1e8993c749a32693898604c1c56a8c2a4e166da80b2233f2d2bd
+g: 279e26642123f6a952227a2f6fcf0119e562d391411ec0acf8bf0346e28f188fe6809db177c7e21da02d2a3cd1d27579e8120126262429181bb1483a08b62aded0cd0d4766fa5cdd47fb229e594a91dc49478fbd60cd5bcde95ecb40b4483f7172e1142ff943b197858459a129e91cbe814cf78916ea819b5082aec058ebf32eb52180bb3afad2bf39dae3e51b02557257fd0b1cb3a4cfb8f6f052943b2c339008adb279fe5e5cfb7157038e099e296b605d42545b0e522ad00fd7324f1a81051996d7855be9231841e424635b550ddbbc24d6c6f381fbcb6d4ede291cf27f8eddf7ab46d828cee8d1f4561e8ca15d3ef643defce090496d27a77960ec55fc5c
+h: 100
+m: 1d228c3e82f29939fac978c77d7f986f289946e7d1eb00f546fee875f6b940148698
+p: 8b11a4e9180e193d12bbbcf49346d5838410ef52e8b1a2889f5083d95696b9936d9be26aed6737fa6d9b6a204ce9b5b8d8c3baa9441e0c8eed50afb7679482ee6632cf346867f1b048138c80872f66c4d4f1b1634237842dcb8722c4d96ffbcf9ab5feb672035fad471bf325bcf97960ffe3deb5081d23298f998a1f7a026495b2b06685819e2aa6f1567ba37b7108c7e7a2e4d79e5a11e5ee595d3fa804d03e55b169f0926255a43d2c8063fb11c5f8d949d745d339c228d61e51d3c0fcd1b7ffd2c5e40e3fa087b5cd95d7c36507bd309ab6b9e38530cae56afee59706e351e3e5adf534bba368b58766ca28f74a5c7c8c86b0f5f249f49137c0e330f28749
+q: 9075d45f3ac52f5995b6fafad1eb94f82961519c306c4e36cc4e5265
+r: 442dc63fe77b2682e4f4f61ad4d152be01dddf27660e62664a4241a6
+s: 1f4c08097a6f891151231f8131fba53089e9e3c5f1c450beb8b4c089
+x: 13920f02359e20635a07f2793ebc4290c585cee32373526f75357346
+y: 157ad5af5db70923175eb01bdbbdc6e861df85bb3a8f4db897aff2996ce267ef9dc1dbd6d4bea314dc4746f4bbf51e3178b80f0210e84461f45d7bba317b1161acc63ca59abbf0e6e5b3ed42addf67119deb1793c56b00f738f78c1cf0133705c84697eb6995d9d4cd246c8d5e21b8ef00f5e86ccf4743a54e1d8bb482d5f241b91020b837d7855f073fdfcb9099c18357a32ce32e32304c196ce011d1ebeb94fe2d890bafc97c4414694aaeeb776da2f2a66ee13c61e1aa35ffe27c4524c288d1c9fe33510a8233e45faba5edb399c40f20ae91f8e24c0a406c352db7d59ed86ebdb7376c1e45c3db1be8f63bc9db704365b7dccb15956047b39024a3afe916
+g: 468cdbbcc35688fb2c1b84065c2d70ffcd392e865ab5440f30ce2bd5b1c1f92af8c7ff592f0283ac1c7a6d33aa4835a5556caf561bfdb4b4789fa07bfb84cf80f87c0c1477e3f5f079a27f545c8a2829950ec4a8584daca1c9bf2d9591e6b42c5ca740d1b82fe0e052573fe73cb0c2db962d41b4b879f7d1273b8d7cfc1e222bfbaa13160ca13aeeebe3b4a31790fefa348b7bc7e3d61ab7d60c1ce5a396630bb2a4dd7ee6ba8bd89197a572d741d3bf22d75bd227bc099b8a52c3292a2229887cdc7ff5f30eef2b993c84d48e86397e667e4630edd6ac09b47f00fcd9351f867584ac76aa081284b610395c8137d846bb19d3aa1b4764ccb7b0a730763bc196
+h: 180
+m: 2d104c6f91aca94e9da1db58abedca454fb3d2608a1e9fc47a643a1608614ea1ccfbd489225ed38c811845f0b5262ef7224dbac6050ceb4a5527a46c8f9cfc2d
+p: c1fcb56e8fc3af466ca9fca45a99d680aa58f46e28247df1b0dac038d8df661b6d2a9e13caa60d2a8311d7fc684a9b18761d48fc52fb2bf98c2311f32f628dadbafcc1c4ad8019336908db7152a4c03ff3f0494936db5728dc8a58017365673e34c23675cc59975e8234210c8df4a4884e7fdc0e88a634e2ce956b6a956d5c38445b06bd4c813a697ddee6e3c4b552c584e5cae10ef1d0226ad778c79d8574bc0d9100ed4cc6177c58712e7256defed2bde2795fc09539e47fc03d54079afc8f32ea77ecabde6390df402bca7174b88fd3e47ecacb2a51acc359017cd6441c8e78d0a19a354233d9ce840137c7a134282c0728085c73a1c4620bda3ce3f93225
+q: ae482d4a4a0f3fcdf0ca44736ee073d5d0952aff6557750cf199c863
+r: c087c6f81d1d2cf2fec97807b75ab6eec4402f19808bb83596ff2f4
+s: 36efb6709b99515c888916965be667413223759a3761c2a0fc81901
+x: 70c6a82cd663f5293fa7eca96d682aced0b392f8fb6a5b29f182b0fb
+y: 8c8d60611fbc01e1266928f7a537ad9557980575bcdc618f350985f7d5b648f72bfded937900627e4c5de7ec28d632b5af96a726c628162ccbffd6997d2e0d44cdc1f0ad868e9812de5c6931652c689604eb63bb73373e0c0b4627a4ac54a480204f5c7678150d1a7f22442023674b4327bc1d31fa7e4867d91ab9abb58d2b2ef3cabed3855892de6212fe717c8df5856f24f09cd76ee9aba097980808f36f7ec1589b2d471d10d2e87cb4ffee6314ca90b9aa71e5495e04d8965fbbcbdeba72c2f882d4181ea5cfd0d5d98da293cc03a223024924cfaf93597b429081c844ae933c10a3421563a5dd3c1ff7f910511ebbffedeadfcc34553d6e4f1449a5104e
+g: 75a165b20da1883ffb3dde970f8b469132c0fdedba3b203ccc3a47c52a2e8f9f76d6e393d32f9d52486c01d136e118e9e43e69918e402898d1caefe9ba433f3a0348e74450e321cb95ff7b55d8cfa535d308fe588975411d7fa83b2497da0219e7b9a6f1fd1a3ade1c21eefe3baeca207ffc4b5d857c260a4d627ac432b94b3ddfe360162320e64ee6d86b5e1684b80edebc348b3ae62b7b5b66b0b6ef74470fde9650660a10a8c3bf15efe4f98186ec672b366b45d34513d58c7ddd0bda644c50cf2484d4ee75d7775cf2e3f9661628777aa7fd2b62e109dfa54ef1fad042fa8ab54fcc7e5956b6a49073ef5166066b171241a29792ef6302860011e2281cda
+h: 180
+m: 96916f7331921d7d15b53212d84cbbdfd33681a65c56dbcb8feef5cef8509b185f5900f30c432133e99addb38dfe4d2c5cac9c
+p: acc8efbb28e8da47f9de7929366307b75b5938c38ad8ab1bcdb31090b45436576c298ab952329e868f37c29e7f192113c8abce875394c719a006a4088b34e71f301210e928c24e3822d7829dc5385e881ccb5bdf39b189c1d236da3c98ab7084dc24825dbafb7df43a69cee0e984356fe764671008eca8386a8db8966e0dbb742c83b8147113142d1fcd4c4241a7ace1328910cc4d3ac885db4b4604dfd40e0851c1481a82f4f9b56fe007b6f987cdffcdfa1fb32e6fe3315309e9ddde55db6bd840887a9480d6a2e32c3ee29a09856440639fee6ed9d44785a63d03537713b40b71d09f76cdcd4bc121308f40fa1fb2ea7dde717eab120a5211a527ba858e13
+q: a3f7247817ad7d27cb798f1ceeae4d8d553be567944489e6b8c8752d
+r: af66424e5b6fcb0d02736cba0e75ed378f99a1a95f3b3dabbf4421
+s: 3ef17b32767ebd166c21d9c00e05fde6055a2105d42974e72b82750e
+x: 6c51aaad103ae26d436008827c5637058dbc0f2ffdd564de20888445
+y: 27efa706b08112bd843147886534106c8a81a2575db36e2820d872ae1c2f41c04e709ff4c877d39893ef54973ffcab1730b9150386fd26faf82e1f9a96d58dbba9a4b2d0057ad84c558ac19f6c41b53632688451388e34c093c8bfc44ae25be56328cf1663e3d7ec6e7bfe630426dafb9caa581859e84d25e39b892479f1d31f6de6cb7c07b44fe3c8adb4f4a382ea9e6b3c46b5b87202fa3075bfe3ef5fa2d1da81431befa336a84642edd631db356565201bdcf3202d7d63d71b5208b225a0bb3e6159a9afdd1a4bf2c562530eb9a20ebf4d5bda79cbe4e9d9f798ec8a334c1ec9e98da604b22f7ea6796e84c0f3ae4bb381015f229bf6e6bc0a3af8dec49a
+g: 4359bd41e4292cf74c7253050deef639b08a68f65df5830ac57a0bbf29ae902ad82561e6791009076353fdc37ca277a4c5de2bb00bcfeee19b5b495f4ffa923d6fbf316e1d23e19f22696956effcc9a17cee537dc142390fd9fe0ba905c13060a047ecf39ad06ec60086d0b446b6f5c4352e1450633090229e56b2eb8b892294d06170a929bcdbbcbe917cd3394a3c5fc78481752dd18db89c578d0174c41ca79bb92a90bde56d325e34c1e89cc8d525da66664f7a33c56f97d2a8a784fe1c93d09912b47cda6f7b12f690a03c24956fc8f8b0f9f477221c265b667008eb2f76e61fe3a92ceeb527d6f3a9ea67b2ae133cd9f09560efe2a6f1d97f66973aeaf1
+h: e0
+m: 2fea6778d7dba18b06f4e928595bf059a3329c274dce0d7c6ac50bc6fc76821b8be30743aeee01f6c0aacf5b51ffcd942d5bc7de4943d3e7d3cc697ad076d49ab37a62b554ea1d0ce79e7fa23ce7f916e5657ca71d10768f37195cbfb6b103aa7134100cc84ac1ebb9547ef4738b2bd18b6b74f93773c8af5444d7dbc72c4389dcb15d21a9f5012e9f05aaf623a253f597c2ec7b31a4ba2051229485d64209834e64d4d717d9bb89103d4a253acee2c47d0e69a05685047d0fd5b65ba64cd76cbfd28a88ce0f049575673b43b22a826e4431e09cfc752b4fdb6bf0b8309cee7e8e
+p: d59970c58c826ce041ebedc022b36759cadef19191b1e4b9e91b4cf268e8271262eccd89023cddbab79ec1eaa96c641f38735fe55b3edf6b586db873e6e1506be69e64b6c2d1130a9e5ef21acf787fee6dedceb1ce905f9fe797269fd995404f6af858a756039202a96b7e0e76a8ec3832be59a80ca274d8bb94cdc54b2a7c6937f40f826330bc6b7b2611c3bd5c14a0999e04568f3a4bc78158338339875ce076a293915562621fdde9eaee54563bd4abbefb4eab4f5bb79ec173dca0240151cc39f3ebde5e2c2c0798fdc75991ff471852104fc737cc5640b6e9e20b7cc0d0a209b84f420e441043f062cd9414004a59c331dc1cf8b343f1da02dd9c9dfb9f
+q: 94e9c7903cf0ffbe3ba033d6de8877b7d47db8a6983c636819c8bba5
+r: 561d79691648a72b27836ad8c1f49157e2b4c71a191370040d644f26
+s: 4df8bb38ea60c7b410105dc53738e7503dea0cbfc23b5c5a4f96eb7c
+x: 3c7bf4ca0d03cef2230eedc9795a26884217de929d21be27fb13caab
+y: dbf452bef538267df67c47995e880c50f378023accbf0979118dfa7654e36b440f5010c17d0cd12329aa0411a7d05e3d9808bf369984fd39dfef4ddab6bb409c0d3ac175fd7eae084520a22365e68d86a44f96ea5f18c2ad8661078f8c2e382b5965349f8c667c24cee2f8f5a024bc27605e2f79b0fa8f11813ada77d16e13b31f51f69b66c0b9fea6883397def8daad8d144fcb8885c61bdc221cdfd41db877c71b37b0e56ce0a507c267fba57e487783319e4bc8d014d03cdea99f285dd9996110ac40cc7b36d13a6de6292315baa24b8a1af64fa678040b14f7a0b496fb97f0d4098c606ee9189abfc665c208f2c450424600f6d4a3b37b870b1ba60abb0
+g: 10895d8026f54b864ae07953556fa245b7f19bbb88bceff9011a9a2b11ccec3057d2b52a2eac52b4401a63d964e1516b21c929fce9126fced58c2b8f7f9b759c78717e1c89e35dbb0998477470727f283718d7bd4389e8eef14828797e8569b13f1d7f0ee9185d49bdd4e3a027b750ecce01fce1a78e786fe728b7b793317cff15f76e7e5fcf424d6587fa3553f002c21ad48b1670ba6388b641d23de98a7a86794778c293f05bcf12982bae3d3d9949518f0f3ce1dd5192dc0847834d8ba605a477f861ddffc7aa9b1142d817b5aea351fc2d54c2430a70bdf6ef307aaf10a6898142d543113af3d215bafca11927c3cb07cff23f40545509db500979d30d81
+h: e0
+m: 3ace95ef5a0daac71d18c85f0b94f603a6477d3b91edefe371e5c06806d98e6eba0c4d43f6fa84feb13716912bfa8ae915b37e964216dd65c411e7784492fd0849a654d7139df78da4b8a212b5cfcd3bfd0bafe8723df2718202d90b3d0ec5c07393f0dae3c3eee54055a2f6dde877130a8df9b27c8feb0d937e5c97e8a67e219a129483f4c754011f0e029ead6fd0e98bf3ebbd6ce6253d4c808aea936db4bd6d
+p: 948282365ddd8782118b1485121f77fa39412eb709b8369c4928d505823d10f01094ca3d647ea59c16b4575d6719bfe15f3979de569590ec76c68559ca759d8e9ce7885c538d610c5ad6c2614b9bd8406745114f62b0af236710aeb2fdd22d9184b44d04418b8a63f592e98a4027c32211e95c6e047a44b94a18a4529e683b48d459cb589db3ce85b2909abfe24f67e95c87dd2dde82d9415e76905a465f53182299d5b37097e4480d3699aa4ca70c3017c9a91edc3e70d48bf0a584112999380f31918312605acc109cbaaf557ada1a3a8b83133b1f33672f9060e40553f4aea6edf68204ca308c1cc8b0181f2d3342145278a7dd898ddb2c9046d59b41b485
+q: 9ed971bff80e4b4adcee5f79a668b4f352d994b3d36b0114d2e441ed
+r: 5a3127b5b3531883e084e7b62cb8755ce064e24151e8c13326f6df7b
+s: 209b627f13c11a78513e79dadc859e98601b1d08917155fb5377e9c4
+x: eec072298e13e1294698348b46ade14db17ee5b35611f1e761d9daf
+y: 5771feedcaea12efba9a26896fe9bfb494049df1c45b537c7b71d476d96906a1b6b5bdb5e12fcc529ee6b4a284fd376fffc4a9a72a47c78f5c69c561c9e2a3926d239acb728887b67577b4f1c42d90270e588257f155a74ce3044386c89596a97d6579f2df2567c96ee4f74bd096f09c91eebeda1fec018a4b8e686897d4aabc8fe2e5aec887dd95287fa1fb446147278f99fb4368e685755f7a0cb3817fd356068cff3ed2ca74735434127543524c74d422f6540d8c3c4499b65268c48f99c20c0128784e7ed111b85c08a27c31175c8bb74793b1ec18ebcb38a4da36858e130f7570d7ee9b4ca76bf4dc3a9e2a7fbd6a233023d8fd575eb588957361788542
+g: 52944a0dcf9e340dd2e4271b96b522ff35a42161e666566932eb0525dde9002c1ccff21f66fa7d2e59596aeb2387a16c7ca79ed7dff2b775e7bb1aaa83edd18fe3e46bd5a819dc62017661d070de533114cc1c05fafb4d46aebd1e1a25060a969aa471c1c9afd3c91cdeda55d62f427e95fe7f1277f9f0c6eb890d1462705d34265748672e94a468f2011355456d670d30fee0bfe2584bb938464001d6dac4e1b1f501d5b23791a381483aaeaca3fb48282a598c6e6060a6df64b05867c886c055f672b22d25a09fab4ff5195fa9f1df98fa52d2ba22dd033e7a1800ee15b248c422349fa55c7492e03f15325309b666d69036a8e671df85c28494d96d0ea715
+h: 200
+m: 37cdcc98484c6777d56d0bd5e5a4a70f7f5a7fbdb7926636b7e88d5cdec7f9c4ab439ccea5a06ecab597dd0cf345989e1e8f1b3d0271413329f3cbccc263fb481d48697c2b7c55bc45071eda47abace55dbc3fee3227dc570f936879e7d11d8e854d00d314f8adf1bc67dcd48362540594ad2fb339d51c8dfef221b3041fa4a78c766500b48deba3e8dc8f7766e55fa20e21b0a927beb28bad927beb0ee65097b2127afbdf841ab0f05f2fdd6bd2daa2927e6cfb0694a1f52e8a0a9ddebae9d8de29119c93b358d7f7beb85ef7b946792adfba4b55
+p: b280aa377395c7f3168592bad72d37bea3b5c55bc3afd5372b0c70fc4d151998385638c48e1af154fdc8b70e6adb1539fb47fc4b29ceb5c2288083d8d0a18899023bf67ab479c084f9680a109be2225af34d21e7f10714a23ce44a87539acf2c9f16890e4582304ce79d5f34a7d836c14e3db53385f0d0774c752b290b6b4faebddf21faf85aaa7facb5830401cbadcd72231dad16bbaaedb178d247eb1676664a1a8af294e9f754b40bef500a00835d30f08491f5efc0744d3f8fffec35d422de6b92874470c95e8e0aba4aa0ed51b37a568ceb8ae4b16f62aafec195a545a5bc717580eff6956f6ccab797071c0b563ceab3db252be451ff62479a8e3bd007
+q: cd2a24b2753302ae9a711371a1f69660cc419abec32b8949ea7490d9
+r: 5741a5c49e13d3eb6a0069992c249b6b376a14aedf3119e8b91256ca
+s: 25a958e1c3f0ec6ddfcf447833897eb6b4b6c21dcb0cc836276d38a1
+x: 2c867afaab859531c2daaf8ca5ddabad8396584fb7f2bbddaca1e76b
+y: 722734f30b8f39fd7fc121db75988eca86032a2cbf64f4f0cdbce9c46ec198547fa246b80197407864b18997fcbdb6562de25fa039399b1ae5556eb3c43023b0f717e1a4aebe5eb2e9aad8b53f7f05abf279d0c8c85f2a08c3c094af9bd2ac0819dcc71fa7bf709d6c5091b9fa98f1fb622b36d39dae3b89f3adb3f711e7f6e9abcfaa388a47eb761a105d737348e93e2a8c2f75f622bd216edd4f7088c1502f040109980d88d52cb8ca07c437f882d53995db24c8f71ed1c46ed2ad7744ef7d95c395d7f88c7a7916d4095bba70c4984e5eff14ec35eb7723f6971d2ec8d974160afba8d71b665b5bbf4ede74d95b1c0f678b939bcd7d30f793dff44ca6eba5
+g: 24348254dab7d14747206fa395219750569e2b1eede9ad5efbd4e6df9a10a8574b62ab2c699079fe5df04b4b9c9429685ae4f65346a70992ab3f100a68a741fd0aa35469918e039e541e73df9ff846ae9eedf1c0f47de14ddd37d73799da478c1038c2322820fc2cff4ed5ee580098ce2887638f8f262794f3ba0efaab07a5a22e3a51d1bd1c777bc742f8950213562fe61853842c0973a30cbae0907e6abc086abbf8993afb023320d43a18a743bf412537e066b9c99a30686cc19d8bcfb4ac91766bab0bb7da0f95220bd881d6b674a2992b9b1f783ce9aca7340d946ed3113cfe012e93d39ad994df238f8b8ef767c4eadcb8365e33091f898b1ff52d3063
+h: 180
+m: fec23a4356343ef6d5c45d70b5c90e26730eea09aac93653a6256c6388986b723406
+p: de28d34df473deebda4e9160dc3d986a9a18886db1d9b5ea5d2ae6215a8eebf148238f637237ad6077dcefa824570ddec5a96e508038c0278ca03fe4bc53cd149806f6e367be696c475f018f7b192a0fe05120105bc759f06dc3b017c34dbe1e2af421fb9d57f9a4c54b89e6235063912076d8cbbbd636d6491862323065ae64feab23e88bb915ad60d95d7dabd85b64cc87690613a9091cd690adf67344573a60cf80f07506542ac409656efb99b2b5633cdb851998e08c9002bd4013acada1e8663b70c48f4868f8c3ec27dce60cff758b328f41b1260a4ecac959e2560bb862bb7f8c8c7c83fd349d174a7487c6e54880c22d7b09fb223d06b2e8bb0e81b9
+q: ea0c2779a444f11ad4dd8728ae6c5fec27519cd858de490cac4339f7
+r: 5cef1e2bffe95bd6deca2ebc526c781dcdf4eabb0794b04eeede111a
+s: 38973f016eafef11f3198eda55ccbdba1a002ba485d426ba01fb4e53
+x: abbbecead270c903761f9e75b4a6406defeeb3ec363b7d91edd274fc
+y: 3c1afc61f4f7bc72418144049844c2e152ae936ae6fe166fe24b1372e2b6093e8e07686e47e14920142121110004750a67af3c1fc47ad9b0621887a07f4480991ccf31fe512d7af0d3e9ef9e2f0d2ddee0722eecdb071ca3a8ed6d804871800674a8ccce5e8bcb038e81fb7edbd48b71d96cf913a65ee6f8ceea1e326254c6c9856c3088acb70efcba98ad25a62f764e44440f69c3ecfabd3ecd8906379aab5d86b07eedd9385671769bf6edcc088f2880555f2097de6ae1367b8c4fac2931fe97aada2e368aa71000bbe8beb876df0d73917d2601be1ff3abee887483b2746554c2b1ccaab1d7a7403cabce90835724ff550860406fb1db325225b04c19425
+g: 5b229550fec5eeb79799312897c9d67a97cf4ace799cbb327ca884a14336a940f5ea72098021a3c5498167cafcf6ef5838c60843a0a90a4c8f120a8c2a9aaed08308e4e5e74beeb55dbc5b3afae0a45f5aeae400673e35966b8ca5956088cb0ec92e12e36ed7dedd10769ac1e2f0d1e198971d1e27a2429cb48a429a85b6e479b4bffcfe26ea94a01b9799b1bb0354447bd0da467bf6c8927b8988b5d9e73db50d01533c77153fba4744a797dd2ec09263d017c4966ffbd3fed208e5f10fb2196bbdfbcb3026f8664549eb5150add6f6453e9e476230b689f691f2fe2674f85406c64082c1281ac1340868f49d3ef70617cb3adb5ff139868da50b7b6571bffe
+h: e0
+m: 20f668f0a94383a7f8cfe7b5d44a892ea6e3a782120535415da9eba5824398efd1e603f9da14d00413987fec7865ba22c034592772a76617fe2a5d6a037fcc18e0720610702e39a982a079198698711fd1a6f60a9b15c374a259961832a95b99ebfd
+p: a34c1e7bae0105d4cbc858a93ecab000effc5f2f3532e359241e0d11a1ecb889c3b7385722f946db89d21c6c09d7a47dccdfa2adb7749d3470e47bf18325559f45014ed3914b0b4a4cbb103a6ffb0ba25f67f33caa4443afe11242cbf7dd855a550796332ca3cb557d6cd5ae35b86cd0c092b7a1608aa0b7c1d72ef2df8678ce8b0c7355302b8269ed8e431cf623942476dd2a62823ccd9ae54255afd38be5d8742c8341e38fcc936b875ca645f97a7a0f3d253720dfab9edb5dcff3da12c14a8fc8b0e6a9d8bc80106ba9db5cb26d69d72a53451fc096d302db7232bddfd27a05c4ce01583c4d93a99a228ba4af839cddd63acd2a3896246780e979680e8c79
+q: c7b19561c22b42a8a796a87bd4547fd31aca5a75b820a027c70f5eeb
+r: 2671b4a2e397a9c62ca693db7ee272a70bfae8499fc40769f1fcc282
+s: bb7434b0dcfe387f2cb023a62a2a660ac1494ec93b3e816ece16745a
+x: 2a213ce1458288a3bfdf99dbd8f83cf1edbecdb0fd6a8308956fddba
+y: a126c1e0403fbb64813e289b54c953f448cd397d98682ca7c182045a708d892872b70e397daf69efa4cac95d7e48a0ca5948ba0ec7facbe8a7b47a2c25cbf644a69d2ccc27bc8b86f40d7fdd393cb3add069eba49550a671866244948479b6c4619127f5a897d5f5609b42ab3ba22ff74a7f4bfb2883d5c8cbc6071ea87e9c557efcd6a84c90246b306aad6124eb93189a13f6669000f73e51066acba830d55ef1c1115fed5bd8ec196d7b26895a797ecaa4de70abde0ab6f6ad9836656e98cbeae16625516097014a5f7e0374f3d61f27377c922e1a576c12a7e39a859de9492d79cda74e75c0d9e65cde3695bc5bc933aa7174eececd3fda0c90581df71705
+g: ad1cda5ceafc0f2b6e84bd184afcb52f90a5f7fb0c01d8c328106a88dca0d7e07603b88fa6d3b4fa7d188800c9f38a467441dd0573ee0c0539e7c604a3de7bcc0e45fd855c1cb5cc6f3408b475ae8e930cda83c751d2e2e2d5941ed9e7535476271e891bcc41c9cc7525818662f4d424098925f7ba5f944f940217ae20d9637dd3f656228f05aedb5dfba34400ea4440b85eb46fc171253e73eae0c4f04f4153cfe6c30a03da578608ed5575f860234cf7229f1dcf2812b13c4ed47fe53b739e1c704bf3470e8dde36c31daa1280c824ce573cf73559773164c251185e5d737338117c1636c3fe4e21e35fa7d33f6b0485cf3d445c6faaebd5dc7dd0ccb74a00
+h: 200
+m: bfa30f498a006f07fc8047ba4a506a1684f314012a723a527fa1c3df0020588db149af335a82ca28bb86670c54d196511be1a1c4e599c15ec988dd7e240fab25d478bd6ebe055854ade6a8ec280aa4ea517e711612bed2b1f8211426ddf3277bf99b994136e94aec9724cce31f69141e8b87c9d43f16c3fea3f3593b30c732eed46b202e559a35e807769ceafff631f84ff1828b21909b1f632a0452b374c650097c283f26186c5f43e2b2b87ad6a6c116076a91545ca8cd6e1a7ae28983aa26bae52337f790292f1cf89ac1a9ff4ae75b78fbfbf178fa740b7f45022949eaad50c7f63dbf7c
+p: b2de996abd7858941ec76995cce8a695dd67d4eea4c5dd6b32da5d709fe347358dfe19bf67264b3ce82247bc933c8bb9d87c8d5cdcb13783305c52580da0fa48bc8fc3444e38fb2dba430de4dac541f7658ee59fa0f69756c287fa2b7ccd036c094a0178454d8e729f3a83a237982ad7365b6644d75bebb3339f77417cf742afda1dadaa582da89d0efb9864d822b29c05e25ae78e6f4f81f0450dfdf6966e7615cade8f94b9497f77cc17de70e426291f1e2b51166f2dde0e0fc9e9bd76a5413aba248505b0b82d4bdbcce4bb901d138effd67d491324e43586919ec5b098fbc2599bc186b3010d22e56f9c72b8fba5b68ecc39f85b8ece879719a0c2f812b5
+q: bd762f7640b4ea7c39630176efc2072362b522e09fff305c9a23943b
+r: 770a6ad47ac0908609c86272170c5d7673fe33551d2072cdadaea0a
+s: 624c5d7ab0811768e7d2fb2fff8008d98f3e14c9885f095607e1ed27
+x: 503f4e1f7a511c41290db2f0c8a99b3de8eff631ad8efcb0f693353c
+y: 6f3e788ba66e87f5da758bde843d50aed13a993d95d27de0e016ee823dfcda0136f50a0b94e65b8b381f6090cdc4b26602719bc98f5d415612a95569b977bab73374bed374d832bc7af0ad3940e9848671925ce6f400715ec1e9091b901c95a8026de3db8347e9fe1c8c3aff7a0a943c980628b4fea4196737664fd57ce584e03574a10294950f243620a4b08705e6bf2d14cef5305a5691474e069d6bbda3691b456e7485482e9a4f5befb8c865a3ed2c4315ef9b60da922166af3b7a27bdf692f0bb7854928cb1205c90d4b3a468f48f76e9751d35980bb130e8f5d42a1ae9050dff1198d968f5c50dbae9abaebb492c41d1fb3dbca13e72a53acac0816d6f
+g: 9f720f2ddddbfae7343032bf74328dd259862417f649cd36d3ab6e14fd686525c270125d67ded2af785c657792fa38403eba552cf6beefe2369353817eae539d70d2b3f1ee090f171cfe882ec70151df77ede0133507cef2c7f1bda2883f33589c1ae0cc20b261386cc665dcb3495517d211c91ae6a5f16e3ec95fa58dd5e30e3b956b7f3946334c8883a2bc76e97d65cc7e7d2fcab92bc2ef0ab3503be0beb8feb1503c408c7562c05e0e717b9c3b9e2f009881eea7ba3b8e84b24e822c430a2b5e64f902605a11adfa427dfd7a467863cb1316ba716f4a1231954ee5aab2590a9aa2e19fdbe6359e604d6db50040a83bee54f76b2404e1811ca48575dc60c8
+h: 180
+m: bef23942b2d53a674c7d1ef31fe5412e05d13aa91968d753e0651e45f258060f7abbab91b02515747bca4aaada151178c2eb763b288ee66e1c6a0b282cec44e258fb2509196e9f919c7fcd62266a441b5fa9f86e70d1a26959afe624730c319074a102b790abd7c2ec45d92f727447a98e65ee36d746dfe2548362be009c4dd8d479b87021edee43503ec32ba0813a9c9af2b8d196f1
+p: aea4e8148c729129bea8c1bae82c792c90afb761713688220dd6cc31b09803df8ef4d6aa894af28f4b10da2504cda0a79785b3b01d8e517f196651f0870774c87a39835d6df61c10265db6a1625313e6342e8bcae50bae778998896fbebf02443e139425f2fa510762407feaae35b0c8438cf18811b69e15196505d82ddfb636cbbc699b6e8dbc468173c1c9eb75f7ce9360f80d98869fd8b6ad4381e67279cde4f73ce62feb91bb9ad7c6198f106dec6957921f5eda9b8bf3b003c2ee5091cd065ec6781ddf1a45702230fc0b7ef2efebc0ecd74b3bfb01c994ed3e303f7011dd56804b7d090cfcd27d358579ebe9b4b7a39e727f29fa09349e41c3f42d8719
+q: c7667ec475c85e475f4055a2c77b5d44a42fdef88ab35341a552d4b1
+r: b739e61d474f513228793dc4665e4d9522c93c0547f70d6612bc25c6
+s: a736a8a51ef57d477e4bd7541187dbaf69a7284d08e292265573de21
+x: 9e18bdad63f10c7926d99e043997eee297250044cf96b8b8cec3e0a7
+y: 6dda29ee4fa436bb8c59e01a94209bd1b234e079a94dc696c04d13ce3b43e407829955deb1c49c102c8487d5e8ba4dbd2d6cdf56bd4b61c83595dda202e4e523eb1ae250fe9f6b76e5ccacde147a0d0f75cc841c15515ef83bb9eb5d516d647e5223a14765f8b9b2756c9ca2e113a746d93fda87478ffc924b829e9f5b2cb8dd1c63e0c60bd6819a8c5df4bb64036d35ae08f1e557cfcd9341b885519edcc859930a42cdf02db0aedce712b8125726e1ca96f22170c258a4533a31425b619bd63d38d9f121f4cea178e9410f6e16dff9a09632165de95ed3dd19bd4a120af1e0314a80e0a8f0aca48972c450c9eb65efb467e270fa2c09ec83f4c8c88cff95ae
+g: 6ccc6a3a6e950cba7c4d01c0912d22cd8528270b2cf99d5d02d5431add6838d0bb13430a724e853c37bfb175eafcc8c23a9859ec55a07ab0eb37174c3fa4d628ea1d40a42b5f3d76351ecf8d687b4746780d733b52aa56d43ac32b3f5b9974741a0357414894085a67efd2b26409f41956bb0ff8a48768baacdf14c5bb5c199fad1db3589d07eaab84765cc32ad43e2d25c457e6e171c3e823eb7e540db0f9fb174b8c128552be562bba5056d2a3dd6ddd69532536d09c1239d0196a8945c95d56ac636c9b8cf622ec2be52df99c9b717de78937c2ce1311db9ec5a5f91e00e745e170704e38171299f851063972a64de76a69a1040dc56f4a6a43a981fdca89
+h: e0
+m: 547ec5b6b6bd4e
+p: e49e05ae0d98d937fa79871a0124e8b8da5771b038765cd66e5df36b02dbd8fcdfa185fe54f93debb6f5b69678bbf647976ca2eda5e15100bbc8f144a27cc593e6079bbaf86d708e238eb8eb3a7f8a6408376657d390864c2c5d8306cbad4b6942a7c21c657bc5aed7fc2d8c8cd08f55dbda93f8ae4fe59d93dacd2f2cdc14b2e67140edbad64bbdb59d5bd8441f9b6af9d9019402dd9ad2457070701bcf51057d2a7a3f634e8789247c407704f59c83853ae6be3d3777a7eee021f42d940ca4a6e3f381c17342e626c45ce5d9c059c8b22380ef7473f94f6cd471ded0ab82a4b3e0a35a940b414a321d7fd09e878e324a40a90b55048b89c74342ae8c8bf193
+q: 8d39c1fe21169a8ac53d32507478975228fe5dbb47ff02e08648b307
+r: 44c0b43f1e82f68a4c153fea0a80c6491f831dc16f5a279b51a90391
+s: 6b87473bbf573befd373d0f05739f1732a30d9fe1bf5399f091f8b3c
+x: 11d912f44f94888e007bded07c0c0b1085b7a06995a7afcbd57abb4a
+y: 8ba13000ef4fb7080d8eba8f652dcf82596b8d64463e7dca533af68f913e2dae697846362426ece2319e21bb1b13f7d5ae1fdf7f5acc81805eadbc3111f4ef810e25cc9c0e878ac739ee393a15cf047a4a0af95408bc298921358c1941c04869eeeda102c77dae198e0bc03f85455197b0c27f7923719d97294a066928744f9f82d446c71e6673be048c33434b13a42e5eb46a270b3f7fca0a4c8b31da562ca643d0364fda6d5bebf26a29a2664bc96df6a2346cb30b367d6489fb7d2d8992b957a1e16626c2898b8b2e457a5474f581f9003678a951a92d5e93a490348b11a201635793bff22fc829e7ba2af6a9d3c6f330c21a01283b5a5e0e8e1cdfb7a29e
+g: 24d02260b32536be094a53205a113d8027026909d9bb8aec147cc74dcdadb3a883ebdbce8b33e78aee6c8729d32537118ccfddf76edc35323b87eef2548d1610ca2d47943e42f6eac7e48d56c27cc440460dcb3e58b23de3c3ad9bd110781b4dbe57349c70419fd24c495e3b924d1cc60b4aa814cced9b5c2a5d59640430ec13684b3534d447e1c60cf43cd461f72a07c79521003c0d24ce4dc5758957973c693ecd1074753e2a8620b4fb45cf182854fd889633c00d211eb985dcea8b59caaa02df8c9b0cfb213fbf19c536b444223bcf643aa76b183c84490fe65599815e9de4f2201baab1783eb707793a4213987c55b219b24f6c16ab0693b948f80e6b58
+h: 180
+m: b150c2118c1df086c44a89f5f46ac1e4abdeaf435ee2fcbb6c72d90047280782536aef0b6141600f9bcedf56ea09b60036bca9debed0e7b4b91873407b3eb9794e6668c99c8f997dfbf8eb34ad85ca199f804844e60a3419c710d2e29bc374f1b84b430770781909db4a5e15e74534ce0ff81a2b2f72793baa62e5e204fb846d1b46227bebd772e10370b3c78963e984808b589b7c5b9c3cd88a423c
+p: 870c0792520dc2fd9bca856b2cc1122160010b67e74f122cedf31fa36a4ea29a38bbf025d62b1a6b6afe79bf31b824335387c5a2559d4cd2af13792987cda6d60951503fe7ce550f0a0f589b3f675074e6dc0db3dde2941927cfdcba0c9eb3997a35f13352441059cf14375357a8dc82c05eed2bda04f832302365ee52bfcbc5c8356671fb244906a490bc413c12aa0c2ae0719659b02a08735a89cc42e1b0da99c6aa14aad051f3b6a3a56d02d4501bb4bdfdc017b46bc79211519f0517cfec8cee0af4a437ad7862a074883b6040cfcc0b3d4b2d59e2e9dae299d3d8be0a2784a5cbdde1a3758f731b994afe1c6e5b5fc5f74720ba5141453cd0799fc8ae2b
+q: bbe17a324adfe8ae7c52935477794d19b1900d59d3088fb540c58aa7
+r: 29a7d9e218e6bf003339216927c05cd90d4d37d4ce58d26706ed96dd
+s: 89fe2895db21e4733c5f637633f0c0d79d56ceeed749909ff6696fb3
+x: 64fa4dfee78b6d8847f0161fd2d26c04314e7753b70c806b4e632555
+y: 2e4a4b437ede304daad0efeab79feb1119111d87bd1dc0f98aa9fd8bacc37bd2043ec095e742238fa4479cc2887d75400704ccd8c967ba2780ff9d47c189b4fd2a3cbf00a68f88ea698dc355b69121a4d62c08c0c5ac1ca5ef5cb19e849fd00023549488683805bb6f63ce96ae5bcd723c5661668f3273a693680982f162174db275cc8a0a071653b565e53d071195ea39d6f94410931ede20419b337104878560efe1ba357cb5cfa0d87f311cf4829e1af228eab9d9fb891db708522af104cf610641804ffe6e0624c763d877666ae46caf5ef648e2e6deac505a9ae3837f0bfd9b8f5bd6a2a9729a5f01f84189dd8891359dccf4320fb2e5983ba1e9a8727b
+g: 75d64323ea53c568b87322faefc3849d7ef7b8c6fb1aa47e71a0c3005e1c9383ae1790d7f68bb486128155f19577c971ea28b67695cfda51b39dc0f5f5535e4dde6f06eddae53489c8bcf4567d6307447846398f27aecd72cadde56370bacaf4283d95e6f361c1e2695b0fd8dfbc22e5f2a6e6fbdefa1ef3c75643146941faab401496e69d5a0d56d8875598279dc017f3efc4f640e11438f235cbb496372d246049d5e901e4404ed851714605e7f06468dfb739c328ed7d11a569eb1f3b383a0326f6fe0d043a812a96de00a13ceae3e3e9cbd118df2f5e9ec9a8443e36e641523f9b844dfaaa54e2d763aeeb4d53e27f15bc695214460eb4147b8e26947572
+h: e0
+m: bf384e
+p: d80499caa0cef1cef769a2320f0c04136bab4940d4acbcefc898d1e776799be624bcb5ab57e677079ed3b25d425adb0e9e888eee1d7bf5f83c11b184cc80390353990777b042efed9a261672f5d26254815e77dd399a3b40f7c7444c191d187a3f307ebcafd2043070776d57e0ca71ce0f8856c3b629a26589e2b77daf30ae1a63ec68a3057c673638a4e08dd50170a465a4857635e2dc51b1dedf90c81bfa94720d1d0209d8063003e3991903a4b3fb87013affd1dcd9aba87e3d4c4c8cff62f52d3694d9d98996021ff22e2183d9518f001dcf5222b5d2d99fd2d1c6c44f1d424dae10933873c78cd2057fd820a462d54c02985bda6c02fa84d5915426dbf3
+q: 882fda1bae239cb8c0dddbd407b81f8f97ccf844fa553f8fe4be956b
+r: 4a989e11a3b887e41964b360339c3be052396e063125a96a1658275c
+s: 6f0e5c344f4dd476a18dc46e60c09ab8be50143792ef05b0df43a514
+x: 6e56d6b89fcbe580617fcad2950646f931e13d4ce0d8806d1f9a14a0
+y: a3722cadcac122a472d23f0d3ea0c5a4992c2db13535b2929154012b12024c40d4016f22ff3343d57bdd8030411bb89dfa1774b88a2cf533aa8531cc92c05e93610f5b5479d4666ff1dcdc1dbf00601c5b2e441a2d8a6f054de54abbadb84875442d149d8ace871230bc67014727aff14e1c104257a6db58b3a066b69310778b7e2c41470c92f2e2f6e270474d9cd346e9c07105b55f15e9eb6a280132c5f608a95292ff20e6f176bcb4e3b454b34813cb9b614963f902ee3906b54510bee99acebaae5274c72818788bb22462d75cfdf1e0c085eef1a61113de867dda6c858cd8e50057477e7d9461ff91097133fdcbba04f12dfc7022e004a4a9e72791ef64
+g: 87cfa3bb1cc15dbabf2b225167decee1480b8c89f9666b9e0cd39d37221e262190cdf82dded05ce000a1c2a11728385eefa779a56e9fc8aa9b81620495039f53cbf5ffc3f5080cfc301fe5e1be779aa8d71c06534259d6589ce7c201f9e517db5fa1800a5cc61f00abda46a9965761ea7969fde497b5e986419bbafdd2b53ff311a1be4093a749ade4ebb6409364a65e24c8305c57774b3ce464d2b37d76edb31894f361b2ca8914e4e738a1ee142f79e3f1401b7be42098b564bc5997408c298d3d60a5ecfc0a0f63cb5100e59750cd2310c9aefdbceaafdc7b2f0837f9dcb1c1cca5a0e160685f128fca4c281f163960df10c4b8d79bf21a8000f8b19a3f52
+h: 100
+m: 66017fa571ff11823f5dde2e72e48d55a67a4d25191bd8214c22ec25b167f17f16b913ee8bba7dab1c44782338667bcdc2b92c2e2ecea951a8e613665ebfd996a2efce1ee8a4ab9af26c154f112de2cd318324ffc4fef4bdaf997a69d6464f485be11864b950765d9e08b7cd6f05afcc0095d70c2af1dd023a9921c989ded4bfe4f7ea2972a2e3007471b6adac16529fa6e3
+p: c9017cc101cc911f7f7969122cb35db8efd7ad372774bc84913d2d16614a22f8936c200711f493d87fdacb50b5a906d1fa6f1d96748f9c6bea278aca7e083a1ca655981279ed5d6cd61ab05bf66ede546f61ac25df55bb06810a2ca8bb29f8b9d67d8b347de1acdd2faab1698cf802cec24014804902fcbc8bc941d4e50682ae69959001b24a03e764aadacadac5b7a0d26184a8d464eb37b16e378ff5e3d0e65815994f1101b132f188da2351fadbb6a52bb01e7ee3bbc2b875bf0c3974b10cf3f5d335b8c91e294787addb02376b32c6dd1b4dee08b142145d66d34b89ec8e21510d3bdb4b1b29b94905af6a41f42a87fbe77d919050900d4791005e29869b
+q: deeca54c111337f74a78d8149b05528b38a5f417101bf2cb6d692e49
+r: a30aef48fad8d9b9514d69c0af32a0089c6e9fb629b63f000bd9c256
+s: 2dffafafadf39d3b1b87cdb84a95f0d79f762ec4614767740bbe657b
+x: a06be67433792c022d6c170621a6c89968a7afcb0dd513524ee7ca76
+y: 60a5b1099c07b8067cd41d5e389fff4137fb1dbbe2dbf016213b3ad4ea1073b654cb7876d27386352a935598392f0723a3019d2284c7211538da25f419bce0fce48fcdee3828c3446e7634e9c1ed0928bd4dd5b07f927452e5584ff93d66ce5568d74eb51f0810fbfdb4313a4dfe5a91d296454e76613cf2be780797ad0c5a64f23ccc22d273be2bf39efb83a345218316db8eaf0f93ac0bd96e453d83bc8c7567377150db9a9327f823644e0400be8b76565a908044b1a30a03746d78790a6d50726d4df97e7e57024162df16fbc11efc29ef34972565b6e634f90061ee1d652faf0ee61ac2ec39da1b13804d645794c8faa1948279b995b977870ccc0561ae
+g: 65c7fe976d82947960c4d1156c5bf92ac3c90283521846085da562b362a1ca1bd1d98a7a3dc4ade86ee9416c9be1d5268275796aa517f8af3effc432b429ace3c9f3b0c71b0c88ee062b2e27517972929d20c6501076508dc6908324d90086fa521e393c87bdb5c735ed5826e332683dee742c09b6302027d23544c597f86413da5a10f62e0d21987b683a9821d37a6c30d062346cab48af6b864617e1bd1917c3625029f4dcb9741b1e6e3d7bb2db592ad55e71ab1e51da891764d1aef7c9236e50d6c4407856bc12810383ad2a5989cdcf0d9a7c4d33cc8ce26e0ab8b12053202140d5a366bcc46f36a0e5182a6db043c81b7ad49ebd7630f0b2a55ba814c7
+h: 200
+m: 2a286289942acdd9044afafc7c8756844152f5edee25b172fd8bc5753d7615a3110b7a9226decad5b21ab5b901a35db84e51dda33f8cdd8360bc0ad264ef7ccf6eb426fc85bfc7adadaa6c3ba1f935364da34b3137f5722cf76aef99ea5268c87d1d3e524cf07c3cb1295b63ac43411df41d7ffd9c53bc9f
+p: df91aef428570f4b57bedfb3eb6e8cc693bd836fe42714a97051a745ac8ccca3d34fe4fcb9c2a6b0a902158040a1b59091475215feec3f372c0ecb32535f3a27bfc6ee5fa0b82b6cfc2c4bbaa2f7b9bb2fa1bc50de2386768c4e38a1b16446a33168680dfba73dc505da5b3a0dc46f3d2de07eda7fed186fed3b5501e2dcbae365b79b0963e45dea6c8542c832b326696c6fae7ae9b0745eb7c1480e21f87627a1bf31bd4a41b26deef364732fe2949f1fdfbbf6cbf0b51729306ec3f13ef14475796b09d153a12ae213ae8322d53a813afc777031e8ec5bdc6c9a2ce2dbf3270966dbff61954b424a3e53153c5abccc8675ac71118930032ba2c8ae970ff8f5
+q: cee328da11f516a35849de75fa51c0ae9dbdfe3ea5bfe2f55f7a6b03
+r: 41bd0317c0048d46f200050f495797048c694e6433504d486ebd5843
+s: 93e710dcd2e257ac8f6f166692213047a44fba8b24e27a3a7590668e
+x: 984cf5a76065019b711ef6b5ae72d1bbffcd9cca79e37c4bcb00b0af
+y: 7fd0d6268dd833af64148dc33ab4224f8058e547bcc3b268a2064f51afdddb037a5c01e0d9c2c1bc19df22de5b8767fb41654b108615d4a3e2a6e2170c7b971ff6c803ea858b588713f398f0ccdd99ac4407544febe42dc88a2712836d507844116f149a4c3c6d96e8d602d357c1322d7c7b9aadd866e397249536be9f4d0be95219d302e84e8396473313742768cceab366b5ab1a330f71e46ace15d27a2bdc240015aec976b24791f071df4fe17b0bc058106ae77d7cf8c97dc12bed26c549b0764855d50942daf43c2d57e86cb47b33012ed235d641d09387d07ab7ad9756e8ea2d328f325529a40253cb2138ce37a3edec54ad025b0c8bdb2c4d62559f9a
+g: a9be072ce0597f655c690378793da14dcf1ce650e373de0f1af5e1aebda1ddef4500c42dc01a7ea69a89a90ef0bdc6e22e033932dea4f8ddd772db76f8fc06c9bea4b46f681d064673c54f50a8bb1264cd6ad1f0e7fd3076a3b218be4e09f3d177805c7e4baf11c0b3ceede646f474b61ed062819946332d4443e01c9b60236293f530f67a7201e01166c5b4ba9b142cde3205fd52356adefdef6927f3aa74bfad2b8d7b198fcd585a522a82b4422b7b8a9f1cdb5947b7b5742bff6810709b77887b3c03450b9691022f3223f323920af5e9c7b94e33dbcf7814160062326dd01de5c8659acee04ab27b37909303bc0f25c9b2375b8689ece7aab5e5ca8a3d2a
+h: 200
+m: 03e2e3fb98375867da816add8e6d4a82eb4ca778101fce0baf67b06c46c5f131f82772db149f95e354590d3a2c14d532c86f1702b42dbfd4d5060c094179ed49fc787707fa4cc2652541c8b3256af2aeca0256a60ce70c05baf343da1b0bccc77f7a15b4b018cd341e4f80641af7fa44b7db33ce23d112b0736b96c3366251feeec284fe743a7ffd55da0e481cd2acd971f7b3acc4757447d0fdac7c1ea5238eaee8cfb05f8a52ddb8725c6a8a55f17e27d0eaf50caaa8cf318c44a49b222c2c84a9f27189380096af3f21c0adbf92c543ce5cc06a1ab06ea6a51dfe1fce04a23792aa61
+p: e3eb6aaeb1b25c3f3078ad1f9acf04a47675b1cedc136bfa87d7ef07639d7a84472b74c64d2462cdf94fb27abe102d3082bc9fd987fe5378a3458b159752e1de6f29df51b73e1163dda3e228a7350313d05e90e7cd5b918bed71ff70d2a9b6925a1eca4cf85090668a985ea38a43275bffccab4c4b8983461c9f855e0ff249a13e97b5e0a42b3752cb186e1024e06c33e69a5c17a196a57262e324cd976f6f71838a21914ddbe46d5dbf9439d11d27ac8afef0e24857416b43332b947dd7d46d8ba0bb15343d614a2108f582fb78fe32301189ec04d6368e4b13201bc762d8007716a86f8003f6c5cbe112f359ea0e848115dda6ca3ddbeb2a82b573817116df
+q: fa0e632b3da513ae32f6945311381dc0b8b2f4602f69c45d2a613c79
+r: 7dd67a091087c056f7e0c7fff9455c8717b8929491186ef22a084161
+s: 3edcc935a52abefadaa6cb8ce862a019f3560f930449c6993481726f
+x: a383e0868354b9474f3308274ec3cda9c00757c4eb56f602be31d6
+y: b47df0d129b4cea76fc54829fc2b2f731794afb2342afcede8865ef1a2691e395fe1c4878f8243a16ed3438bb6dcc4f2f7a885a9e8343bb10dcada27ff68d6dd448793adba320eda2158ce647a20b0d01ffd8b563068cc515a0ca14eefed9d89127ae34bcd5c83d6bd7a94ae7dc2028db0125e536b3ff5bdfe984b1b25a16f2c90b33e0022d7f0ca7edc55361a308c2bf51656f622edb05d5b3bf40ca5ca50497ce05dc27a8d132644e100f8cd62736074f599732241fecd416566f85ab35730e7c0d17e5283c42808085979111235969a167ff719f07e50f3756e667b6e0d3c6709daf01c5fb7cc8daa0a935c9221c252fd1db33ad51979d2e332b9edfae6f8
+g: 6ccddac671b83941e71f646b9c79d49557f321be8d3c12e6bb85ad192d1087f4ce2d1a0f50f3bc01fb25040fdb693e02bc2f4a433058179a1e55a53aad116b2d57df58b95001e883c6893b77f733bd61df324a861cff3eb730124839b1af3095eb2bf42324d4a731e2e1d496a520cb3fa5939d162c86deff3351a88149f0ac3072a37b2a088996cde1d0b01d8a9c0504d0d271d92c6e5c181359aa556da45cb3b41e92c972a411126507802211073c96617535af1126b65ead2fc04b1fd7a386908d60e7ea87f31e31e5a4389a6101252e3cafc98cabfd77d7b098adcefd5027bc6a3ccd4f12760e447628b36746ed78dc2c764d515e4655edb57fcab8256247
+h: 200
+m: ecf0ead39c463b473f5dc14f5bc0ba7d3fd49c0e0704e71e17279bf9a4f95a57d5fc318bef02c8c8c9cda539c1cbe39d15e03804326c1a7640292461405558a215c3ccc9f3d4137814180f31cb638993ba5b1f67842f4939bcaa59a893bc7263d3fb5f8c37de90bf57c93fa0f446f7c650770b62026cf23d4c3e2eddc4fbe2366c73a1e83bb5e7c4d10991d9f9975d56139e11025f5d1878f080a065ef74795e23689e6036482c92e0a06a873dac5618995b9d51d1a9b88f9b1fc28d2a13a1379eddf682198f9cc6d81281c88129f7532af7c3d775731ebaf3c328ff5c913241dde4156549fd1ec4a17cbb4c7d9c
+p: aa4f0f1b4465a34d2c1b1e6a1f06744908745af870ee626d70a8b64a26682a7032063c8238dc2b49a6d46ba4c4f7935db689bbdeac9924c655eeba70fbadb59f6357921f48b2683c07cb7185d7333f38575b951fbeff8d7e26034eab1e833f400b3123233ba3c77dc6382668f094ae42d7b62e7dd74daf5976f8bcd0ffd2db75c49744f21c58f70822674064107ebbabc9da9b675ff649a2d5c26c98a106fbe3075a77bc68e9bb831218046bc7795a7ad07ab068a7c9f64e4690276a43f93a3423ff387a16935d4eb2367e9f94c268df6c2debcf59392d4b9d38d0c13f432771110e2478dacae7f1705563de33891e63c4fedca7b40cf261c57768b3f88d680d
+q: d824d48630ba78ce49c0ab4d3c5ae2673f9d2e314f89e14d7d68d15d
+r: 5a80062bda389b2a4416906fe797e7e410bb7f5451bf616cbc9c7f00
+s: 856bd4e2e5bc0dfb9d2e524b1d9454c563dccdf7d1facfaa8e0f6420
+x: acaa6a3a87bafc8b3b10bdd8c0ee9f81bfb72a8c21ae5dccff0c7574
+y: 53b5865e147464c8f36b74c0f8616bfe8ca4e102de9541d630b849367c174535dc2a03e1a8576dc22ae3eb1826e0c0f52455ed670f7472e243643f0106d812d31480fac0821fe6801eedc6b8983e214448da514a049474ef848b9443dfa0ff8299ca6f4d5aa292deb830511882fcf12ab0a27b28eb893298de8463fed0ea2549c7428930fd949bf2d633d47f8d6392c4ad7cfe377ee31d87be9ecbdccb731d783409a1e5b42142df078e74981cd5cdc95e8a5cf3187160372e2b699350c67a9572e7452bad8fda89474c5355eed20b07223b44d0152fbe76f035878677b9807450e4db62d7d41375f493a926c3e76208b9c36fdac19aecb18ed83ecaf820f8d5
+g: 870052d6f67b4807702c6169dd6c3353c5d5f46aab6b72f27c846c455b1bf634762653246be07912b5cbf5b9bf15af6e3208e8cdd305e318bcd729d024f29798c0aa250b0065a2b1d8b49ff8bc53843e83189ea261f7fc04212968c199b52312a4b946c0bfb72492c298cd5f1065627fc8b975824c4af69180dc33ac7f1f221ddd8de7ffade22b09190b195852680f1706abf49d13c5cf220a5a055d7d73ce9a24d8d0941c40ac92307e4f7fe458157539795192ae4c0bbd6ab6c6dae5240eefd08755ec48a2bc743eb103c02f0fc76983172d164ffbe0cd01c9d4c9c7c4002e7de59ea3a3f042b5b0349fc4ea483de5845b7deb42e9b353a01548822a2a9396
+h: 180
+m: 10f3e75820ea903122854d32e15052049840812b461220b60a7f0482f51c7cee03ff17d278f2d17e7dffa51c8f402f0fd418ada776d9c38b44b603a945397b63f508409122ba89131886fb7a75a33389cbe0ca129cd13273f96002b1a892b8cecd435c4c9bd7fc7de71183cb6af09e06046db11802c62d40136b47d3509bb509dbfb21676df2123c37cf6f2d71fa74d4ff4de0856a78c2504dc51b2dce6ee8456a43b49c7bd468cfa8d80aa886386970b0f0af419a7fb159cc46ede50f739d046727979de6bade33ca5ce45ef98dd6900d64f96d2d
+p: a23a425464a2caa7d94357f27ffec09294e1fb44f638f22a7dc841a061ea05cea1e54ad1b5b806e08950575bbfa6c0fbdd18449ba73f566096e9733debce6b5a292227c4cd55ffcabbe57c0f381f3cddc93475ac22efe9ce61ef93adb92905579d0552e94786f297dc6f31e310c54acdf1a240c22b808866ecd89f1e78d72e82615ed5d34693a66ee2b05c9f1943929c66f4322b23d47c92c1869f76f4e911977e154fe8ec197cc95edbb3492d4c70b36fdc720ffbb0d9d35ba6b83e6eef91317ba1e989b63bb346f8fccdbb0d8e35ed6117525e91ccf635dcf000120f30e92e41b7bdb7719b3f0a9346fbdb0ce787848b2e4ab6ee9e84a087f7b703ce808575
+q: d739719c439d4e5f60d8985b4b26a11f0dda24bfd36c50928eb61661
+r: d5420263086476d3bd55339c3d8bf8be7f957bcb90be99d6a2d0baa9
+s: 862918007c0eea2b009fe66e4693e3cd1b3e07baee85a0d842c310ae
+x: 72f2abc751911ae780649680ad28cdffed45de61adb49c3d12351d54
+y: 5ddcf7962244a259abcec9bbde726bec6318c6ea28a86831d5f5fcb671e7f884583249f179bd2ce947acf843bc871a848011ee0cc07158681573902de1fc8aafe7fce113b588205d9ed3ca20e645dc5f677cc90d058cc048607246aa6c0f3cafd9f7104b3f4951a122c8e7ef44963f911df7719b578fb119977cb6f7a0e6a2355e20c94da8fccf9df99af24c99f51840c2a4dc379a34838bd4972a2a71df51d5803f221075951fc791126ff54dbb85cb1ec2745b9542a369dbb30c91a68fb9a163883011a4d2cb11d74838af7f3b89ff75910672fbac9c0b483958bb720df2e4391298df4759c0d112e16ec85655398e4ae0352de55b99015d07265db5a63ccb
+g: 26d622c515bbd2179944c8d9e28732454eed9d7c4774c41c0bc71780932ea1bcfe68fb629f6a3fb2ed9df294b97e5241e4c7a1bce749205ad116feb2c67d1c52a1f5236144d7b1733a5bb98aa3107f0e54b3bafb8825b2707ecd7dcb18be0ecebe6aa34e2ecaaa508dc5cceff9a136da1041c7bfed43b0e9781f97f3c9bf843df70c207db45d5bc234521d012bb9f8a18ad71a39018e1034b66ce75cd6325ea51af2cec370f3cb29682a68d70f9c62cda8f93b738ce8247d7c87fded0be6cd4d0d5d89fabe17fee92fabce76e8b31aadea9e05e1e63b2a96ebb7cf5a841f34e4ebc211c1b23c1a143e658a7337d5a8ea6de553e1e55ad2d8cb9171b41b2f6453
+h: 180
+m: 959c8778fd22ff7404169432a96b20cad155aae3ec8bec2467cea98550909ffddc1a33de9490352a1625003835b2e2a201db12fb285b216b5fa7ae308b45fc9ac97c72d4b478998a16dbe1670ca050790df68a6f8bc3f0d9b89ac03932c1a49fe6092fcf521a4070591e3c08137e935f68887cd368800ed56bf108b1214c0e5fa3637741586bbe35b99840dd9ebe9856128fa7eba2895e3eb910474f
+p: 897fed6dca830b525e7197dcc462505366deb5c0ecee0b8dd86e41c99046acd058a09ca13c5d400f31a5d54562dd77034e73d24c55a9056db6e360d87b9e4b488e4bccb81cf4832823a004445e2fe18745a486d7971a97bb3aaa497510922ff65fd0679b221ba7bd0f1c8972bd19d68ad865e3de8056d963ed4ddc16089640aae8476a2dcbac5e2541d07d3ead334f4f82ad9c64a69c915b1608220e310bdf8351d8f54503c02666af38e40248d2525ac4676b3a694e95a447dfa9160bf14cbeeca3e817ba296b3874df43b3cfe888869e52077c0aaf4afa35e85614bf2da71812a83945fde37e3b9959f33b2813ce464fbbe4510940ecf4fe95a481fc0dff39
+q: cc4d76b5dc27dca0f50fa9b0b85b67c26f97de6ebd9ca59542aa29fb
+r: 6a20c2c5f5b5a3c44904b587498e774bae29e919407a18c8ac1df50c
+s: 1a31e5c33580eeeeff765e8b70fc8193b4084c5e0aa004d94806e837
+x: 4a9aa4be9fd3dec0d6f00738a5713053bf704093798fff301f4ee30e
+y: 71b9dcd25aa3818606e7989dbb5e04516f411dd181d0a937c2dec0fe0081dfb7b9ce73d60d0a567bd42297e644efeb7fdca61df2956558fa9939b838b79320bd91209bec0cb277d1cbeabedfd239c41d2ed3b9b5f68c3bd32e71bb138759e19f667c461a16d522f1ac0984201305eeb58ffc05173a5a6017e2cc931804f78546eedbe69da0b7c2748cdf77636ef0473bca4beef2de8ce28153b9ca282a06514bb8ced0383b8665bffffef01e26478732e722b21cdc9b52558bed81f0c5c9b4fec5680e1fe090e72e740a6dd475365940a2c644faefb6cbecbd81c2a57c0b77f29c404fa53e05f7e181fdafeacc3d375897cf8e9f173519cf3adf5966216028f4
+g: 10337c43b477e5510f230a78535ceee07135dbe749bb776810415514cfe8340a16a45d3b48a5f12158eca59065f1baeccf19816ff068ce00d609330cc29dca64f6ab3968808fa95056b3d576153b6febc23138925beaa651a584a04f55d0b7113e7aab8ded9622aa342eeac8f89b0efe03556970cd1150e40c44fae3fdc01d2866690b349ea9776045e4acf22982f18f7737f367b858c617c142f0d07de9231b59b156fd387acbddea610914b666593a76abb5049d3eed79a52c6b30dc5ac16d1cb7f37889c50d9a90ce89c77e2327b12be744ada98afcdb7d639b266f0f339c052dd994497846ddcc299d15a8757e3c1fcab33f65227dc7059bda459850ae57
+h: 180
+m: 499bbbbc79e51656368fff15e9876c31d1fbfff5eefc7df438ac553eed3821e53f4dd4db57414f72a65f71c406065d330d57b39e2a8fbb5f477c50557998e29de7134c3a30d95d5337d9e8f60599cdda2fbc95c6f240b97930682e8b092e05f1ecbcb8d0a9db308c514d58177b16c47a2c531861daa4fe9b176b595230f19a2106797a844c2b42438d217d793f
+p: a299f58d3ab277dc8b7f426750e49a7954f0ef3201ad9e73c6a772f8d82fb391af4b4b12ecef240a4fbc664af4c77f443b6f449b937eeaad23ac1693726d88cf9a4d2597eff61cb884dab7c81c25ebccd2d4f77c5080c153aa2cbab4a063605fb71c677df5e719bd707c30a4c6d98e6814e8ebf4b65910f99aab6a19705310a5df460659689c4680ca89c04334cfb82e5bcb56379fcb28ccf87ef28ad9c946b77d309966004aaec1aa262819990a3e5207200758debd7625959e012e081ec2af78ab90908f962296d62faee66ea47168da2e6f786bd9dcdd7dbed963ec34e582a68c6c563dc74c54509a8ec3189d866d1841931b08212ca3087de19081a1ea7b
+q: a156158c92e1087e2311411d59899b84602cfe24fe8147afe612b075
+r: 19da8fd681dd05eaa164c76bfa898118a9a11798b636c9195886f4e6
+s: 8a56ed8bd2acd2ce4c8957dd8030cd0a8405f755aaa968aaa136f6d5
+x: 4930cdb1c058d93a3cbc0f48da2a90ed5a5fbafc1cfb19d6b53dc8f7
+y: 9945530acc4579c9e2f8d24a2d1d108c62e7e88adab1c412713a571160057cc4f46b9856453b2e730e0cd3f94f350e70b5bafada6bf20073a01ecfa85b4937116fe09f36868be9f96ea8b9385dbfb5812550fbe5d0c7f00dbe12e5df66f7533079b4f55fa1ce2feeeaab3df86ad074caf682d7ae5f940838f2fb57ffa2700432e11e4c2a14d63ec6b7d718fd8993fb04957e12b046833f9dc0341b7e4acba9d92dc32346ef74879fc4b4a9e3c634630de3d7a32b5a14829db8c24f44442ec807945cf01f9e67af574a14597ca2f3e2602214d4494c1047e40b1a244f64a63e846746661186606508c89248836e48939c3832b03b032a2a0c8bef5e50356bd5a
+g: 5d26063f4f8a1e60f6fb40ae830a733c01ecca3df07cb66561f364fdd227bd203d3b38075f0388ed2107feb8c95d86b6c976e6a8f38ed55167ea319bc14840c4521ff869e1aca2242cef6f97d920533b3c017b2910630fefd5470a3d982d8ceb48742356f045368da7743d4ad23436db91309331437bd8bdb77647dc28e6adcbe4b874aff4cb9f30ec0d92a205e0655c63d0be2c9c0b35d7a2e9f8936908ced6926ea5884f1f8534b0c5976fa2687bc4111007f1443b5c0aa67d99eb883cc50d12ba7f46d65de09cfacad981c4bc4036ce1fb32a84b4bab5cf9e0d04cbe0784d4b873ca11e4f6b2c5846e4c93d436d81eb6f171e855b76dd42a04791f4cc325a
+h: 200
+m: 1a4c514e6f77d885f495cff2975fb8d27364389463baa349bf9965016501279e043da73b019c3fc0b3763ed21df468a53de5a333c8e4b5795f52f2b852707f6774dad2ad6c7b861a849a3f36cad47e85d9a85b85af29be54f38ef2
+p: 8651c980f2b9a6f61ff50b21da3ff07c7c3e37b7e3dd4b39edef8d84299bb6b1946a6cdb56fc81e0742dce8dcef0b7a7fbd8a63ec98c1deea6aa597d647b8165f54bd0874ab3985cac3aefe50315936451fee2979256729df379048fbdd702e66fea94e0b873744701ee20d45e10dbad24c78480f25b64b309b77dcf834feafbc72213ff9fc1eb1cb5b2a3594913a27b0de3d6d3b2a6c80df6cac24a16c2a19d42d6e3fa16036bfc367f31b4088d57d6eaacbe428601ff239f3b47504481989394692d8a3a3f172cd6ce9cc9be42977da1610e050aca4f9d89e87b2280c0c670ce58ee0ea7a78c2b068e9a496ff38b3a4f1c18a9df9faeafffc65a9bb873720d
+q: f56b14311c589dd4c332753aedb70c3a50525c33e4264c70ce4ec443
+r: be7ac9e696236a3c6f43a07d370337244db2631f1682fc517d904d04
+s: e1808b7949dfcc5f8389ed4cabce3953f49edad6005d34381905c9a7
+x: 82989b208424f015e5fb1ee768ad2decbf5d8e948a2c008a9bc06270
+y: 77fc554a280753259d06cdc97926184c637848d0483ac4abd28eafddd26943120a39969a75fa58341dd8d956241862e98417f239c9a2eaae82870ecc179320c7a3bc546a6c88b0a70962655f15c007744dc106f87d2a4c952ac8b10c24004c11ee022bce91a4b31cb0bacb861232de4e0f85372a8d8d869757fdaca54718ac1596ca11640bdeb2fc42c9a735871c0d6a3d07d2a08bf80f51868f383a5b106132a59ca19c74dd24d1e6bd13cc00cd8eea871bec0ddaff15ad67478d11f30b2d72d22683514bd5205af8e438533c619a3425201ac1c3df40d058b0cd1b24390ccf321a25a186e8d24bda71cc735b76b0afb2d61ec50dbbc442c0765e9e3839482d
+g: b55604bcdacbfb488912963ee4d2bbffaedcbc8d790eecd9f624f469fd978bd98d4650bc9612bce1f1f331ece2682d0881bd655972d6344049b58e2f6e370eccff71e37c062b329af65363a60dbcb86df5d8ed338e7efcc46e007b396cd5b55e38e38f523f3c5831f42a65f999e2b2c65f37f6fca68b27658b5a5b9067c95a655fcc2f38dab529c8bb6b65a19788e8c545c1483c54adb7e2d68b25aede56424767f7c9060ca05a602b71d70fe409ceb8153ffd2ee3cc42b5266ee3de79dbd9b8ec2e3823c7eeb6cea6d8a2e8e1402f604fda488f17ff24dbdc9d5b6621e96a1309b043f46f24f0dfef9b9eea64174b0eeee07378e9fef9f9b7355cce97860a6d
+h: e0
+m: d6b8f39bd05df380d28bcf646bdb703b6257b4233be8866843015ccd65c07bf8cf58a2838a34a81a5248bcc96cc01d45b08ea1ac96fda2316736440da765fb53318e720bff6afab7c9d2b97184541aa9f524b307b24783f2a5f51897cbeb14e14abe575d067ff5c5c5d44b729f9887692d1cf6d88d0ba2ae23787d1f126e6b7d751baf614ed5c77e01c220ff28e78d32c95b1106083a195a988e59cf626f210e5c577f44128f7f59540402cd76e8740eecb5f0a1d3d1bad353516f9bbbb2c69a31731ac6177649792704a4cfe945849f48e8bb03b96aa92e277c024df6b37b231d8d5549d286580d4eac00781341d2b91446
+p: ba9ba55eac9e2d9d3c971ecfb3fa8c608ae90a9ebf580e67ee02e12f754c6eb912e5810f95ff1dd6e7f3258b339057ca28d9913e41210f3f50ed88d2f8c9079df53a12abd18833baa575b3650910c6cc9545474b53e61ad953d8690bc1d4d1850529ffd66851ec865e1e84033ef60afa2d1e2f3784b45f3297096458893476a68720163c723e9cf86005859caeb1f5f0622f93f1e501c7205292487f962f2aa14bd0f5c9d8f21ef3f70e2fbfc2b2901c87204cd430d1cc6e755e548729689ba1b099b84c06eac344dcd62552f73b33491130fabf5df5c3b7c8eaf472e0c151a65f0f7a2e5b80ad3bef2e3a83f1087a264a78437907017954445ba07c3b6242eb
+q: d28c838fb1af5f837faec31f9fa7cbaeb413a05da20e0b865cfc0437
+r: 5041b1dcf6e79b46e0c1863b4b556817a9b0f56dcf6db2c19313b1a
+s: 6a004f442294b7e7a058692ad67e94f423b55d004f93b0a929000a00
+x: a8150a7de89514a9010c7cfda8832705dea0badac2357dee732ad340
+y: 4454acd4d4b9369324c9d8834919f1a284f9bbd63a364c56cb01a4a5e22882adad02ab816894e880565b695af1a253636b99edce3b2df155bc28422308fa70f5f20fbd09826bb3dff0bd2ed6100949ca346a111f97c51a1aeb46b6b4aebfe7df61868ff6c641738c51f926e607c5795ddc9a203e578e0138b523607f12f96bff805d1a8deb30ece68c97964ab06db07a38ca633e4b0dcd1f3feec754754eedca917d5ffd2ed503ff4cb92a2751f282d97cb0d4b3b05f9d243d5788a80c01df81d73dcac4721807559fbc4730ad85c321eb2ea464000d5d89d6f4174dc0015c38276773d0382f359364979c5612f965e33ec8a6bdef16cba505d5730d1e302e51
+g: 7c3bc89ec219b37f14792421727b7a28a95fabf502dbf398450fb348c7f217f79faa26b95b92c2eb4f2ef91b043746e5e4d04e3cc32540a1c2ea4d1fec03ebd4bf3759169427e8ea8993c90ee1184d098d70eaf7233419260038d9efea3a386786f255ac59caced17ee7daf15b6b15bda4b2cefd5e0a43a691be2cf91238cd234fbaaa69c97cd4dd756f8a20616424d94f20baed3f9fe58b8abcf34b933ff2f0513fd27962cf12510909c611b8c02792dedf229ec1debd14f21be566cd902d21eb114b1cfcf1180d45143eda67cc0ce0f0251f9c2d8508e0101dd60e2da26ebae08c1bf759db806186a770c2372fb133efcb95872cef79fd9e9799078502d183
+h: 100
+m: 1c28ab2e2ec84b62617ac510db59c43d4815810122e9ea90ee9a84cd832e7f6fb191bf5deb8b2a57655fd6e5e7d03657406ab0f61a7f5cd5a676a54fe775ed9a563e7e2a94b9c62c64f1b0f6739fdf6cde738acaee9624d5f32a586e7b504b9ebadf55aa42827ffe227282240d49f0f046b68250b31941784d4c9a848f93b615d7a7ba0e68b4d7812ad678d4c476dc52f8ac9e8184f4d632178e0aaeed654f8f78a2b16e7a452959dd956fc201584767ad71dee5f40fec96403586a030ef2abd6e58a477cfd5d3adb0ad4bcf110b1f80648032fe96
+p: d5fa68d13e297726da801b0d27987a75f7af53e82edae203248943973376db0529b555bcc7551da090dab460e756da16e6e9eed28b979b3745ce7bbb89bd673b4d287680f3615fe0528915a28ac3afacca400bce92792d42bc4d5a5dd49842bbb4a749c926b6efa38fdaef23957ea10bf6b7ed20deb2fbd01a12ae8ab3b5e22b7849d851bdbfde504db275d6c60bf94e9ed5eaeee45079fa7dd5359de561ea21983a3421c1afad491d6baae56c816e611ecc975b073078c464fe653934b9a9eec64c8c07715ac22ff5acb9b22cd762bc661ce73fccb91723e6ce168f91ae3f999fff7c7e34c0cd0323111f8064afb64db11d4537c23adec4071cf13ddc307277
+q: 82d6654a6a5dfa810115facf190cafa0fbdaf7058ae1ec6058a24853
+r: 2ecc267656e94a88114418f0715f6861f83885d5275a12bc136bc02
+s: 69f24af8509e849beee2e38051cae4a1492237e124c282e181f20fdb
+x: 105be11543080821326c26691132238f49cecab6bd09040570169076
+y: b3c7c0f1a8fb683d786e87a8bf86a811f7b95dc8bf5b6bf1053e07c33850cf2aa963df0dcba35a8ba6879244f65abcc077b75c8dcf69d8143b889991282a210ec07d6b127aa3ee3442d6e32099c0c6e8ff4bcca2a598c8858f416e12834a7b6256b2794e11a05f77f3527ea876214a3a027783a509793afc5242f97ded6a25660e80c0f8349cee906da6f4509715b15260ba21d4ec194d5552ac81650b06e27bd8aeee22ff35afe55cba69da33ab2f252b39b62df2be59496383b60d9fba10510966bc6780af46e26c165e09ed31a8741cedcb08c3768f8142b84045af17e76a325781d446696dcfe869bc5529879f0e4910673ff637c9bdf7fe355ae2811d25
+g: d24bfa14d1ec20666f72eb921e540bc6c6df53f8ea5fdacd1c1c2cdb75707847c1b2f9c2ceae7f82116499dfaf95a8f19d2851dfdbc084bdad6f4e77e2ac48540f49460fec12ea321f3f080a136c30306ef6c3271a941d44bba5957388d858330eddfd098056e45e12ad4f7f43b2cc98eb157c1a0b22035a17e92e6d9d7932766b1960e1734fe7f1b2f72914402c22e6733051240b958f65ba8ea649e51c85b791d2a3c51bd372d15010ea3b6c19ed805415adb75b80327eb952411fab2f133b5d36c9863f08afc01e3b57925ab1acd036c5717d96abff7d2501afcc0727d03df63a866a4e45422778e1ef4d6a716f1cdb1323d474840754cd507a9e5282edbd
+h: e0
+m: b87260c6592d0df5263b4dd4c2d6d4b219c8750830043f708b4498174eb78293775e6eaa20df7a8572ab8f3bbb
+p: f60a8cc7a06f33e28b6accb53c1fb8578cf9c7c1195d00f802dc035c2b9bdfe8933b807012ef9feda2a53582c88a00b776d63a519714eb6694714349c9064c7664befea687b46ade42cdce4d28c85a2b659a478b40df460b0f275cea53553d5b0112d503fb14e43c52d8cecb78d84c67e41ea780cb87521ad417cd516d8e79f011e822cabcccd93d2917ca9ecd3c2befce50a0d01194d3d7320d8658f7cdc0b48299fda6ee3f94aaa4667be56a2243daaaebc15b33af79f4f57501649221148750e654a6ed773aef71ae3a5a7cdd1c77ee3e7cbbb8d37962549991f97b76af6bccb5d1a8d65ad4e1863a97a1c27d2a992635d38a63b805309fb10c73ed85dbf9
+q: fb17afff01d84d71057e2f2b5411f2479764161ad4ced285c66703bd
+r: d0b65e62664a2e035ce9e9dca72d87d492677c9afaf6aab0805193b9
+s: 3d94ce41ececede3f3b1f00e6564c599430ef8db68ca0990b3c5dc5a
+x: f62c07351a6745dd4fd5c1b526805cc9cf770c675c6d31f610d825d5
+y: 53759bc7b20c37681c00ad1f1f0683a51aaba7349fca6dbbc7a6c5eea9807e100ac5c25924c008da4c8536a27169565a2bdbb2b81e839bfff7fd88d705158a287e1e129b46e30fad315c5cdcdf58834c58193be10742226473af027111b535399163a2bae02bbd5aa5c03060b3fe603f72c872976c789cdcb107013da6fa0fdfb610375dcba780e163512ba34b6a246f9c3df3d1520e947921f8e84c47db220af3f21ad622d2d89d5ea944210e0d49c02a494a957b3c610ada20dc61b6d4ef20c4271858eaa818809035c8029a833665835794543682f0a1415b6448b610d4bfafcfb3cddf666043d8b237c011b4d1c0ff88c0aff530a95d75dfc0026e2807da
+g: 3db3021d30fcc265b6f4459b54f47bc586533c3b9e66705b1de75aa4c99bf9542af1d503f87c725fb60fb01c3b356e2accfd878d87df328e0532b0b5081c896bc654980a543f43d4630c6c7994736e9e791f64e844647c640bf0ad53a73ddc615746c4371eeb2a34d322ec36a6fc405c0b363208235295bbb268a1b4664c6e8eb98333f427e2778858e9cb5d63d9b4ab3f7872b275059301913590d8ded70a255c715eb5fa4c1e29daaf1ae31a41d98acd97a3fc8855b7a8313d69a7477aedf4d98345f191202a99b1be23c245529708daca00566761e6a181721e9f6ff4a2ba25f3f1ea16d482d738da36cb56b5a617f9b3b35c80c4180fd9fe5d12a7699313
+h: 180
+m: 2ba5969034deadaf4e4815f898d51fbcb957c44bf4cb5386a03a3a3e828eb8ad92e96d60d6fcccb1e6bf8b0acbe124237bb67b6789bdd03964b785ee1b2cc4529c8aab3880835ac16d2a
+p: f1013f7fa39fa8d0afbe5322002d2577f7b081db014c5bbcfe9503b379dcb7227eda0032e56e23c5090cc814530ced2587efed95887de95fcd0f4e40a4d0b1bbbe154628d901d06e4a6c69072a3cfd40b751da88fd316cc1b6df712ccea51a981f9eb20c3150cae92c847ede6f837624f7354087628976ef77ba9efca534ba0539fca779e40773860b5e9a365a7a822707f2cfbeefe78753331598a1215647b57ebd7649e83492c533c5f85af81261647ac410cce4f3aa968383374844cf95b17d730d115ca12a9a78279cdfba785ce92566ccbfc22553eb18d738b9bbdc28a79a61653e77aedefc8177bcec4d5e2a5d3555a5ec6346b23f53b9bfbd9989251f
+q: 8ee70200c95034a6d07e9f8f7fadcb5c54ddf8befc6731d4bc01797f
+r: 7d07c010fcf91650bfd30e2ed92a515eb0816d43f87f9bfa54e3fbbf
+s: 8978b89f966ce017b87d9a4a340aad284f12cc9e0d13b9e59f1afd83
+x: 8465720b3e3f50818517634584239b80e2b8651a46e7acab84510d4f
+y: 24f02fe60b5eeb43a5b82ef899828f3b4373f06e33f55ba1517b531eaf15947db4c99d3eeb363e45db40c7c152f6955859f3939c2eb7a9a9b00073c00e8455d6e20a89fb911a05c225d8b62bed7e049788f96824147904ba14b46d6077d0823bbe314e3abb1ecc9f926254bfa31650a9864db19664c31679ad9ab44fb028cd9b0a8c1330a340831bf326ad52bfc5c049459e2cb2834680e6c229f9c235d29066c5cd795bbbc234291c0488ce48f9e98f47b2f75e2ae671d4000da85782d9303583dd961807c0129f79bb1938c920c2e908c6071575ade4c5951759ababf8a1d11eb739227a95eb92c89737563004454bcd56b17841bfe7ce2951de6b61026d1a

testdata/dsa/signL2048N256.test

@@ -0,0 +1,459 @@
+g: 3723294e8a68d2de71190ec5088b8c8660ece27710da126a0516988fe494da037a4592a3d674b3784c09e9f1c6874e86dfd99b16158a5a0f1f7d792b7f227e56ade3d515b6e7e7c8824202f9b4cda90b52b93b140101e2140d0217f1d99c01fdddd16e79551ff71a92d92b18df829bcee2967576063c6f204520bb66e26e6b6b039de8dbec0b18b6b8a075974398c6fc9e7e550029ec8da34c29f9a2667e4b837acb18845b5983dc8762f96cb6e6c4a90ce4b8e29a42a5e8b51262c66ef34d3b98a12736ee29e9543d493142fc1f1f97ba333c445826d9bcccf223aa09b8a3c648553feb93ef00045b4880fc4c75796e989955a3a4d84df1dc5817c55668d135
+h: 200
+m: 1be605ec89ea98c433af398370542efd82d9cd0ca3c9ee935eae055172
+p: c15666a4eee2c16b2a9f986ce8dba494a3a62d62748c15183a1c9c162adfe081b42c55327f04753a80673d3d42e394247d235adccb8bc7913f0616b2a68a5f7189b531bec32a031dca71f432f5a14d36be825466b5d95ae15819f78c378f6a47e8c946893c3663789154d17a0857f158693f59fd1c188b638652dfc5e77dea49f107cc07e3be1db267b8194d1e1e72e7fbec4762b14017cee8413d8441d4e3bdabbc1775f1b4e55bb68bf30ddd80dce5aac25f23f7ad111543595f811f4c396621847f1e42037b8fb7499652bc167da4a230cc973f27077a66278f608aeaffc4ebd6e37b7c86ce518be4c7e375ad6da5bbeea0509d4b9d24767f00988b29c12f
+q: e7b7b398d905b948ac0bee07a494fad5f7e7ad351ca8c7944ae41c4c7067b657
+r: bb70ab67d4c9aa8198103010c855c2408206cd9b1f87a38a82da1fc4b81db02b
+s: 4615b7fe007772d68023e3c350827ac10b59cfef328da0662a9939cd9a78ad2c
+x: 271afc425c524a2022a8ae3455cd2d4b8b071239b770dc27b037dfefe821e990
+y: 7c2b885e2d6b3ef2072550b9cbd5b62736e1fdced6798fb791e79782ce39119362d6ac850406148d917b1efbead9cae36896c463c8497c64b4f695d3583aa47bdd10f2862161610d30837d5e83ef1febd6677767bac51fbbc9393bd504b54a7b443802915179858077bfbd581771c959ef387fe22d1d7fa952364bc8e0e7c7167f28be470fdcf5c09a41be268029a2ebbb75afe96aef36b0628b92a7f91137823601251539cf06ad4738aead2e74c20a8a8a4f7f413f92113c89858b699583ae7e4f0af5b0ac648cf1d1801d6320c53480e653e02868590a86dbf7bbfc7618311da4a17e1ead2ddf9169ee86ce31186feb7a351d9fb8548a404b5b9737d639b7
+g: 4a44b54b97efd7f767f0e824e38f75680e22fd0681d828a8cfee860d774ee274f58b4ace823caa487447412fd613ff0588dde6a0e6260e14544b59837a4b6e5e6f51a00b19a7dcda938b4de916edc788667ab38647dd674191eec19b7bff2bc4bb9b8d746deba9494aca7aa26eb85255d75b1a8ab16dbfceb624b99c43c30c333dd567239a99abe155c7af3d376b879963f7b04f146a10f7b2531e35a7a12fefb534ca41a957a3845ee8524e930a3c7f18278c8ec0bf519c9bf7c16ad030a0adab9741a336402f0b84e0e93efb84a41f3d485ee0a599251a986ee931d3e20baec79eccc09bb090154a817d243b58ad914c22f2a214cd4b0b15c058188ef3abdd
+h: 200
+m: 4a0f7282daf3727975260c582c04727db4a86d4562aa336de8d33276781da4d87f157febbbf8073ed1f3123feda9ca68eeb7676508e5a304f790ac0f29f65b972282f740b0754735487d1355a6f4cf6837834b24d0a198e9a7bb19bc6074f6edfaa7d260e1f0a9b79d7dde951bd4d25bb5eb06259457cd3d7384eecfa56c14bdc442aa0db053966e1768234d4920fb0d1f0707a5196495ac4b2186001ea8c3c71453ced898991ff248013183852e16aa9817e2de7c33
+p: 9ceaec731f3c706a5cdf587f4aebd1862ac7ff15397afa3fdfc6c4c537cf04236cc44d1bad4ffdfb325248ff1e22dbed732f1c5e6291b0772eba18308cc20f3248ce62b8c0c5df0168aff913c75dc414c10a2c4521a2833731d7792d3acd528649be17d8d9a7b406d17852df6f308a9c916e6a3356b94d27db3fd05cf9baca2041d619a13c2363fae7cfe8ee32455a7d18516fa13a71d88db345df5fb7e8a97e1e692d57e1a640f07437962cfa7963c2b08a33c864ebb4f7f489dcc219887f526b7d55b7f4b0df7fd503d0bb6c0b4edd079df38b286566d18e7351fe5e34dc808fe9d55c53038b0dd31b53826d5b54ad82a1c464c470227ce86d457b2dc16da3
+q: e74b4e501b0f6ea8c0d8a15d85f3b5741a8ae8893798650cfdef92705f730f9b
+r: 70f062c9b247f93531f81678d9004c0aab1e7d96a2b607ad32c3cad060143119
+s: b1402bf859da0a66e88d9af1600df1f68a2723993f47fa6563664f8ed95dd5c8
+x: 13bca13e53fc79cd885b51d2c8a6c243ba85dc29826644c8f0b3bd2d012e72e7
+y: 176220e3566743ab3b9bbe4549b955e5f57e58e99d876494f293439aa4f80041290c6de45d36d3916e04bbb7bdaf952ba4d3329dcb19074ef5809ece64a37686d50015e169b089df38b25a7b4875ae983cb8a3ade40fb0804f051891783593245b6ae9d26a6e70490bde95230b148e8e8efe2ebe7d3545782b40c7f54aa595f5ea591088ce89fddd0dbae4af62ea78b5954ec9320c5891bfc4879e78ea2bc599136a3adbb6be5a7ed372bf62b75f28034879f1d2451f32175664360f9598c580d099902ae21cf14c5dffd1a635ae44e17740ff39717016a3bb931e9e8ca57032a1a3fba61aceb7de9a6ad6ff1b385d6b10547ee901115fdd996e14f2ad303ed0
+g: 5b132511ea4dd82c71fc64f6a7ccc6e611ed1fb5af214ce499b90a66c3774ed4e83ebae110b6f1e87f1259403a0edf05356e7e2bdc0a181eb28b98aff10ca01439f802387e2d40700cad758ec6ae44cf7798f81184828949f034dbd67118e5ae23c2b4a1a227183b43dd4a912abf283c68d7e0f033441eaa31ab60d8bdf27bb127586e38948f237d73075bd80344f7c386da5717f00f90b6e5be73ec95a19be8e27f9d6fdb14888b7a0beae71efc47d6a8c116e48c9ddb049ffb54e5c54317b24429d36a3ab3c78149eef997314a80450d48f3714995dec29fdd553cec1049be3ddf6874dfcf14db52d0942afd254dceb835b976b5cec0bdd7eb5e516a7bde23
+h: e0
+m: 50e97b87d28d30a9038d39917153fbaef05046d53d4d7e87eccf816d4d37b90c3364e17a99
+p: 9101a8cfa105eb288bd3f16dbc89b262c89a6204aef37400d434b30320a35d4beecb2230e89a12951b6719ef7ff650dc28bb9bce7ee93db2decceae4932a5fa59ccb369cfc39ee054998f5d52c7294eb304cfbb6988d3b3bdda6ce432f9fb14ba22835fc53ecb7fbdf24332fc28001f549f2494ddbabc491e49ad1538825547aad6b263c867cc10495da172f334ed1a4ec1921fa04e6c357c674f9e91e2ed806916feb2e29b2937dc5d0bfdf389b91e4766c71af93f39159ee6c91c1dabf3785089732c6b09d40e7164bb8c991e8d930eb346eff2ecc98552ed9ac59263c18cb7e24f7c7ac38b666b117031e5e19e15eee91787754a4d781df81984f1c23bebb
+q: de1ae692f0ecca7ebe72a0b96b8f6f827213f991412e83b9dfa044363806b377
+r: 8e2d8ce7183a7daed0019778c980e8b895fb4e34cc201f4a435247a42d892cb4
+s: bf32509a7563a6bf9d302f26b09500b2e3b8e6d6c4e1b9fad116b582fd032eb9
+x: 9086a90f6cf02f95e89a514a183d7ca166d0f9dbe945fcf874f61e7a9b74fbf4
+y: 2c50dbab1a4d301d92bd4e7e216b284f31c22cee1ffb67d38a9501d3de2da3fe024f0bc316f29b5876047d7f4882ac970589510022ab600936a58fbca8263c99b741fcb6dc769b1b016f69ab0b55a0cd84f799759819d31626d0d303126d3aed7b55bf87752abb9752394151363ebdbcfc15effe6dc6a25989df274440106316b08fc46fa020eccf0cd198a1f897c7a26e47d1b608a61ec0d3f1f247d9fc8abd11120349aafde3a830052226258a99049f2cb5e3776f0c7d08bd542ae20bbe114e3f1f16412b23e1e23f74c99e963fa5cc48d11a483852d7bbb53b68eef63a9d22b4146475bc588e3d4ce695eeba753459d14e10f4896c300a8604c17b123ba7
+g: 20257c394ff38518fa4a14ca49d20d45694c6d392d6fdb2d2033ba46707249144b1c29206ce08fbc6b40683acc99a4acb204b14d44f4b61e0f04dd106d63571fd6df8fce235a9f290e17c922e07e455f620a958f2c436504ef0909e7c6cf579c457d1b3d7e6072db792e74bf49fe2f9da2d3acc3b970691f9ec64291d672e6f1712ed6f6aef2f5e6e3fc60f8215a9275a6311b85e5f707d0df3dacb42da4df99c7e3cf98b575a0526906bee226343a911c573d3e9880804e80abb88625bb407b89bf7d01d69cd89992a6656cc0060f1517cd8558ae6cdb8729d75482c4dca2a21ec4bc6cd03bf6d1c5cf250b7958190221e99d7db7d52d1f9ef3c62c6884dc37
+h: 200
+m: 64
+p: c6c8355600809da95c969ba155492dcc4a2c51e557eee187d9cd9c5a9bb8e8a0da1aab73dc81257ce0e0d8bc17ae505a813c0625098f5d7197528e1f8ee9c5af8251a19e5b53dd8bbebd8d54d30ae34b90ae83f39636118102806b49a8194536d131e1b2232ba79ab9d1457d66d6ba108f765d1e80fa71e7f35826d579b5ad6d200d7a1729270216aa90310c519777f073d80beacad0821da043d4cd1a51e2b12269e688287e84f93d0899d399c83d72dbfb0c1c81662a1ff5f877c02c327369bbf9127247e7c3af1faafa28f3d38bb973dd7c6bcb4d47359dbcbf041db2fb2dd9e9cb610bcfbfa20d7ca463a14c6bbeb26e825a2c060000c6ec231a6081a691
+q: c2c4fd73ae948ba5a72f5cd49e09f406955fb9395649034b4ceda56c519a14a9
+r: 3319b4722aa1cc420ae7c3cf1caf936743574fe1ed8a35207e934eeecf27433
+s: a3d548621a10e9dae0b9e8477c9a6e1d2acd192232068aafc22680b4632bc563
+x: b45f87d480e81a633006621fcaa5c630ab8db6bbdd2a09a93064603355748996
+y: b859d1fe410ef7b6252d58a5181faee5d7dea688fcc2866fe5ec6ebb21b2df4c688579f66f62ca4eec409a38bb1b334f65395b3f9826dd868d9a982eb15e6d1fba578128681d64c6b87d83b9df138b3956d48da1c13f6c82b10f8d63bf943f1089191b04cb0177840e61cee8f2d8feacba8c8e3283935f16071483d5c786bb80c6588917160cf0c676cd8401a1f2970b4f8b476c32e215e5cecebe28c0247cb5b028276ce134f136c8bd0f4d93bd856db664f3b199174a818c03f7cb32fe71d82763e7222a6b693b3f92f72d5b6bd31ad730d214478037bcda843bad9fbb8d1fb419e637327e58b5da9c7b76215cf7e3fccad03ccb35a2a17519b46b42afa9b0
+g: 72a02738cc0633576e7727a364b6b1c85bf89e1b6e58527fa035dc4399daefadcf83da7a853ab66f2250479c459bfbc3bded589975143779063b3bf9f2bcf166d5f521c4d276b19bddf710eb4f21d0b032b5c74f6386d5a6ef7262f627bea61b18c0906ff56789cf70387768e5ac3a0dfb15f48c18ecf136d3fa5922a8d6789aad4d5454ca812c53c87e68c64d0e07f287ed508db81b434aa331ae8af6fab2d60adba6c448433b04e5012842eb817b64f2981b58297d72e22939498397648a18ecf97ea12670b6b92c37a0b3b5aa225a6064eb106ca820aa5b244408dff5460b0f4af825614022f501154cfcd2e222c7a7cba102c4975667d825fad9e58e352e
+h: 180
+m: bfebb28b42c0261d4c9b10db95c6507c4ff53b3b19507a34a5061c78ec859813a70badc8bd4da68ecb23fed46c2f22524da51d553508f8f71b3e204961e52abd6166e71404b41c4af2a21da130df61f903bbeeabb7753690276aed516b8f7fa4a246d2d0a2e5334373b911a2b2649e8f33f980aa4d81472c85627cfd6252494ab00b9a
+p: e5796c9e9e57e0870389056a798a2865aba0155fdf0a6952aa267413f83f34dec8b4514448aa891ef66ebe38a042dd2d70be653c00d1398fd9307a931f9ea798e727ff21040fcd9286ca09b49670a9086d6e7c1689eea2922b57b5c456d4fb6e2edbbbac43d83ddfbc57d773582aa2f603878434e9e82ba1478afd519e71e6287521e51b90ce4c64d2e4673a25193d072160471b5c6312201cf0125e0da0b0635fb48fcd110e71a552a1ce4a0ffe4064143a525c6ad4fb4abfb51fb75b4d7c3e62974e4cd5d7e69bfa1ea23fb9445da8a2ef11e3280aac9a13ffc429b095083a37ebbd96c106473174442afa71d736a67754b8ecc336646155db15386690d94f
+q: 913f4e6246eff6756fb3d48852669f91cc7c3e31c03dd42b1edbc3e5f7cd4bad
+r: 40304e5d068cbaaf061a56f991a7829c59235fd59c0b2df0ecb2271b8d6af698
+s: 80cabfc8bf1421619127ccc331d0830c1c7c243994436e36e9528df2502879fb
+x: 61e555bcab1b482eddfe17800aab2410e1ed8663df197624d0da5bdf4d643993
+y: e3f9a25239da793226eac79255f682b5481a4752f1eeceb88546b7a7e5ba76bd1bb06c5e28074c9d3c7e3c5b61616e6bfed3226d0d562183aa68e23247a8bb12257dc576920a56ca52c9af5f3ae90c178f54d3bb70724cd5095c2ca6e020cd8fc1f0234d1ca739600c72c76f9db94c2714be6b3755ab4aa5024f4bac50154c9bd8ff4ac4508df38d2240d35c232cfcdd00e6b60dc46e19d241ed5bc4d4713226273efb3e4c7be2ead6a835850a887110d367fe060e7b19ce9f0139d4421dea12cfd67f85461674b90ca675fa7bc383b62cb076af71e9cea06ff848403a9ba2f5ca3cd60df073fd236d23eec1e8790fad20cca5a69653976787a51e3c0edebb05
+g: 3e10ef9a225b2ca3cf3e45832e9865d7460247ee62ad7027a7f2e265c09357215b9699e8b74a6c438a3d64d17b8be12852daf2111f77ec365fda9c45203486ab194b8f0858759477c02c2846c61d695ebb2ac95bf1addaec131a1c4ba3a4a1ac71d6afbbb0b90384ba03598b91954ff4a5393e77dd93d2cf6a2647b581f6d254e63794664a54d9ed34b4d483e39c2eacfdd4ef859555f5b859429d4580a2adfff377875b3c302e6f5185f982d0e1e3b54150af3e438ae5d520a31fecc19aa7ad89a060464ddf774aaf262ec233640378622fe9e0712641017344cbcc1a48bc6d9bff14aca5bc6d6dab2a1f2fc95c4c0b795792f7324f27fd080dfe2c71835c1a
+h: 200
+m: 9764db6e977846b864da3d97b70ad6a6fa7e630496a4decb09429d8a1fe6ed3d703832eb6518
+p: a7b5b6c368ba6d8cb1d55e58b87fc2aecf8ef6d7df5e53753b7de3eb87c67c3aa499fdc53abf5e83b48bd7b395858345f89d1ddca5368130282f439e5a1ed2ad7c92f4c4507ec978182ea76a709d018827192d0673491f0444fbd25341a6bee82f8420ea344e114f4251fd8d6551f342ff3a1d8671c022a9ad24b86fa1405505fdc7dfb0de0c0fd3688b41fd6f5bb4760d4d0e1bc8620bcea7008b5d3f255ec13d556c67be263465ee241101536f4ecdaae230a2f5842b5eea43a1d474d4d990686938b7ced589f310fd90062fd6d8c6ae3c6cc402de2c3bc4ce74c5a65253dc8b94057b70314d145967e9d8d14067b837a02be51eb7b315c49d8d5936cfdae9
+q: 8bd1b5f0475433678efa756bb234ef50a4cd98a5b540e519fc934bf8e3467f35
+r: e7979153ddd7d8b21eed743d33af7e3425c50109495a92b220004005b461db8
+s: 1d756e9a1c41a8465fa7f999cb09395a4a5b89a3b875181fd7f0247d78be724f
+x: 3f0ceaad3661ee163823b68a1f921cc699a661d6ddc5d509a457352a6f62e414
+y: 13ff0071a9549312efd58b8b3044575e6976527d681ae09c117c91351a58f55b88ef05c1d9242c95b374bdcd609ffad5604bc6bd01c8a2b86a8c3085e1b7319831530da7b0747354ee98c064956335316bb815d07befca8358353b2585a2b585700bd97c1209eecff7e056d819e7aaf75a83050292414bd83b2eadf4af60466c8bec7a9b1a560741cc030229b2129afbfafbddfdbeede1ca2c6568e7f0d7418a3638d07d3c68baf135b50df0aa0dcdc3546e3db8aa9bc9d285d9439e13d0f63f88ced0878bb3c54544ff3f9639207a58d3aab6df4f9097d22166f0f4a28eb00e9e8380a31adfb63c698fb501fe6c22ce8d6c1c8e3fe2f77f4cf8bdec0e5e4562
+g: 5601dee6c5dc8fe8b01e1e2feefee8fbb3726c7d8506db67f06327cf0e6479dfde78183d9d135c4cee8f1a9e972fd281c7ce875b475880d8bca540dff2f413ba58d2fe773a4af2d3dbcb8a38a4be2b7d5da37e62d240ad771888abff146c971df34758642721002f5b7d5f14b3c32d61125943eddef41368a0c8e2fb21db16bff7c6f81f9b63f9906081cde0e33cfe92004d5a0fc7c19a69b25d292b22c651113ba6593096085f60cd674c6ba39623a71f6573f6229584d340f791d14fba9f07e6acdfe62ec134a51ac1e7a5665751b31fd37087b48f2967357d75a26b31b5417072ce153036a7c8b22dcf735ce3945a5a73ce7a67c5c5d0a627458931a5b683
+h: e0
+m: f6039f2c63c24d785ccaf2ce3e5b6177c7d350afb8e350655384595b972c5748f635b01be5139a4b8563584bcdc803c956d2199b12da9a01005fdb4d8e4731e912972273287771164c9d72a1160757651d68f508dc96a62665696f
+p: b49275a04039eb172a5577990db00e2bf31d17b1f193f50f64a4d41c359f8dd97770df4023d54a42fc6e832113781c533af2aae2e488c73245be526cd8e7288faaff72c25ca39241d941c91a0ca03026ae7808dbd410031cf0c99b7c2a6516e83ad9c762fff2547cb6f862452a93761e75f449d52e7e30675ca7ede88bca32891940c9f92647e0b8ecbb4e9573a1356c08f4e34f2ae009c066d3c85f93c0115712a49ba8b6ac280d986ea64c95644b6cc4415287790d80a9af6109311af9683c3e72f893b62cde36c5ffca743bf2ba2ee3cb5aa4f996e15694fc9cf1bbe7bfea6111a2e7430230402b2104c3ed8e89246619884177e94e8b3ec3f2d24768ca91
+q: d9ea638b88541d282ee5f200cde887c039d5f8fc215fc0f2248aec637b26492f
+r: 95422b51110d9bcfd314fa5d566455943265d89138b799975bef4568119c3553
+s: 48d5d6b36b852a7b7ba9fe0c288ecbaac4eaadf2aed6738658c24a1fbdc781de
+x: 5e70fd65ac76b93162370790464eb3298d4b0e28aa71e8ef777be8f6bbea7a11
+y: 19efd86788353c71ab7bfd4e80dd6e8fd4584ba05f539320c4616ad2bb955ebbf9876a34a0b9b5f29bff5fa99d9559d225e87c7d262bb202b917f1d1e4c68181798fd003d53d2bf94bf5822789ac29df2feb99d51afd8c2855832e2a47ccfb38fa23996796162ccc78d512188301747267fbbafac2d5eee7ac4466bf40867ea75162df7cc00e2deb2cb112e6deeed16c5a129ea80c85050afe692781b8977eb678f74dd076acd26c239148c331bc49294e00063be022fd7c191ccf5c4987e833f95c302d7c0bfc6c98a96ea89f92f7392f2724bd5c084089b15d669f6d301cb2a0d7a948fc397449420fca17d0856dd399d4e5777317a0bf3a8eb133512bb48f
+g: 81f1930fe641d803233a995ab7b9c664fd2afeabaec9df04901d807e8e0e20eb3afe3e227b6014d53e06fd1e06d2cdf16b1b59fb09fc41f030e1a3490058493d5f31fc62c8a9fb6e2b9648b1b84d628a85ab2ffa59c3c499d4058c392a70c25dbfda2c3a3c6f243d6a9c97e647beb134b06ba129ffaf8b7204fa53f6729da151ed4f627cff93811b9cfa5052823c8d956e6d6dfa6189927143098eb89b0eef210fba4e36421647af5eda5e4a8160d730a035c181743373b2cfe8c8ad6d6a4ad3c729b90230109baaaef33fbdbb54fd84702e95674cb26bc38659b2197838cce4abf6c151ae27a13243772aa6a278ccca705f55826d4bccb641ea50c2aee842a7
+h: e0
+m: 7cef2a12cb9cee361338f3df15300fdde6bef6cd2a131c371cd61336e0d544fd090494f9e3740f699cbaea8f488309a6620567fa4200b8b5da544acd7e15ac0e78d762ceea977b12870f71f7077b2667624576618fd7009c8f635fae
+p: bfc28df62da811722d7462f01d2261f034d87b6a9273e3deeec690a7016e3aac61bf766bc433aed81d559582ddd0b35fd14696aed66a7955ed624bcf8901627a8cc2136bf645b8ac60795f860c69ed91a566a34862d02b6ebafe6489660fdf28c27cea8bda84f048ffed7a195fa6f0a4c79d6fe5e034c61281e948bb19ec12ac330d4554441824f749947758e09ca008b221b0d24b4ab6c821a190f600b5181b46d8281480601f57ad05a799e237a00e602802ca095d71dab367f328522c863e8e88aa93f470606e184a83619f17441627807abb0b1ce2b6c82298213008304942fa3b50418e3885e57a4e5f66e2f66d3173ee4aab11a4cd29b29412accd5519
+q: b98beb2e42bb15c89d937128545fcf5e3d4e6939fbc103b4a66e3862b7551e59
+r: ac28d4f731b4430a16317cfc161f33af038dded46b7729f27ac6961675926fc5
+s: 6fd2f08403af3d683c3f4e16e521d95ca68eb4ee1c30a1acca0eff1ab3b8ab4d
+x: a5268197d4b07d7a2ce04966961e700b0fab0c5637a17c7b7a17352373708b66
+y: 7fa870da04496f8437d16f198ec2eae0e62258c61b8cbe6188b7d47153c27fda2ed650ac54e67e7e51e62d0fc1b0ae3a390cab5669e5af88cec5940446f40f982db58505d575ba81d93d73be675ea145695cc6873428da6d93a5d669650ba9b92ed4b1a6e9f8815bec0ad32ac453cd209265743c34c861d62f5a08d159f5a750bdaa59f6678ba576021898c06edfd9b074024a997db600fddff367f5fd1d13eebd98947c300c00904f90faadb5a7f784702436d6b9450f28f210186266ccabc9e2e85c794e9f5e7ad941c57487c8106add7060523b8e14ca5dd28e70d662b2b7aedfff366de974c31082f014ff66b82ccdc688cd1f3b4af49f8e1aaf9eb6e883
+g: 308e776f8192c010a3d7d86c4c072d034a10a22152cc80e68ec5bb718f433357ae15d95b78dbea777cdbc54bfdd57cfcebc151c173acbaa8250d1e4eb11f852492a12abcf175b4a4c4dbb9275053aba71113552157716fcfd596e65c79087dd5348d0a47b6a3b0c2512713e409f0bf0f1644ad95abb6a46da0d5612842f4acfa2acb0d8cbbf902ce205781c71e72ed3fa113513a608b8d9865f36f0e03f37d9ada20cedabd6e3e16e77ac1f24bf5454682bd46911137ff80d858e7aa9be9e093824420253e229a6b5cde1894b0c78b6b3525716c96236632b227615693eb0477d0ec4070700b2ec2e0e99cd2229715772255848bdf937a144f8880ac49285545
+h: 200
+m: e84158a7d082c01541e1c89974522b97391745d673b0b3cb9def4f121362aaa80bfc616fe8e40754edb96451c3466b6663cc01aedc34a45147f0d86d775944fbbb9b993551ab81b90472479b8878514d2b1b5cee81bbd0ba346e7070334d53eb87a8940b2c539aad5d31f0a654239e70c335628eafe3d8d8
+p: ea62d3303656b3a2a06575f47b8295c4d8c7fee586362b1606a699409a0a4b6fbdcbb3b7050ce5379db1acbeeae53ee306f9571cc16172b6bc4263fab59f8e86cec982be72e1a26aed09194733ec19d8545ccd6e9ea0ba67d86bf4d22d5cd1f83af823d381b4aed6462a642db2e2d3616efe0035d1813823f291a95fb18823960aa0bc741a735ade737f77d3a708bbe555d294d016ff5f0ccf17b67743090d36d6749fccc22b56c850de70edf3967e00af5aa1ad7058c86d786332700ee741d0388e95e0ab038d4f2aa1ae999e250bec90c63b40fb7ece76b923e40f6322c2571f8407327d4cf354db8f1e3dff35aa5c400b0ee91d489ae8938ec1378f4a7421
+q: 993c84ec2d07f444caa41ace0a6a63c548107afe0f422ad5fe68dd0558139f59
+r: 671f81e8f320e48cb5ee78abf5d8d84513f9220e684534cde26935318f40de3d
+s: 4199bde71701590794a75f6d0c25f12f9a297169a59f3ab2eabafc5d6aea9c24
+x: 748a8ad45ab2b53748affb598a6f9fd23825790f9486cde9a26ef91b8b46c71b
+y: 49a63e1b9b23b17de71b1814c045b9a3beb7be369b5cadcc4aa9b669274f94bc67917a0c958d0f96958e1b37abbffcce931be7a57bd74dd2b43d0d2a6002ce7527dda7d575d01612e46612b596acfb468452c7c5c884a062d3043afd4b0502187d1492e8eba1ef6d8328af4acf5aa501e4296ec7c7572909ae9abc52178ff7fa486b9b33e6f250d97408d552fdd4327404d675f8bc4be9ab4786f1161c1e3ff684fc821c3099871b964a1df9cb982bc53f378d6d4a3c40c36bd88fc19b185d56f67980806e83157704e0adaea1cdf5cccea1adbf5bb7f57f7fa845bdfa5fa037da4dd72e47c3063d39e6baf4c025bdb9f3b7b119b26c91ab5b1d6152a21796a1
+g: 1bb4cc9a14981287198b2ba1b8256e854723a7583b26381ddbc405a4f8eab76df604fd5e9216e166a61771a08c384879c344ad3c20d496a56837b76a99efe0991bfbeb59450092d4cd1e1e30d73c9b4a8ad20d3321e93fbc5accf714e5f86494e9e9b9b655e57d9f163beefac04e192ed72163e3790538dffa6a755eaae941427717753d57837dc919a6ff182feaa17fc9f5261012a893f6c55821ac0e8a52c711d740d91f8357f760640393da75b6dc4ea613627a700d2d95050eacf71fdd3b91d5d1c4f605c84d15590ec265573e7e5468297e194789e6d687ca1f53c7ba261f02449e6f4b0854f563f2c7934703dd8770b7e65176db84f4acaaa9f779a36b
+h: e0
+m: aaac3d8361d0125e4f9bae9ba22933c41bdc4753ba389642c1d5e1751f36848fb68ab326528bbc98aabd6ea7e87dd9c3aef1f3f097063cf7da3dfc39b2ecfbaf28f6543db2719088af0baf3a61fa3adc2e8ff54d65a2e3218d3f565632a1f5c96c2ca20c17b3f0ab2ca4539cd755f35cccb4d59e0c009f33f11666c4a1e53cf88a353feffdda3b6e6391191217e0c2b5a3c9931a71a005a77b8b86f19d9395deb3c46ddd7eeea07b598bb2c8e6b4473afc389732f95c59c432e7
+p: ad9a921b47488e9fc698e0b2405e302ddab742b66ced95bda0c3c5bdb8a89e6b2c764c4cc7be2181cc63d3aa592da1b7788753a6103a09b4619c8e1d32283fd4f6cfbe3dcb27aab16bd468ecf3d1fbba96e1d004bda871329db0fe852612a6f5980d7754ed78032cfe55559e2126a9af32c4987949a804d7981842d682a192678b6a90579b943320f23c3f69fe890ec7f415982fd5665bf0fefb47bb2451466cc7beee8067685589231f433656b718dad0054ac65fe248f932d7a8cf93aac54bd7cc648e46ec94a2de42ea224b675cf243f9cf65e08554ccb9ef49d9229f604d279e1e8d935f9be2392025f00f0e53c74d33821bc56aba7d84f3ac8799f0c6b5
+q: b7cbf0fa23c7cc6e8e49e8487fda84f8191a32441e571fe7ffb5956bf18e7035
+r: 9e08a8ad9a3b6def8ea63bcdb2f3afd4839b95c6d537daa2b3b78c89e091f0fb
+s: 7cf83052047d53376de53fdd67913a52b7d686dfb8634c2b42798bec70103220
+x: 7983a33de8a33c333fe853c717bd55f5a8ee4b67870f9e4d361ed3abc796d94a
+y: 87b2f2d42c095fd0689a4e0cc6b998343534b72cb4465374b80e78d8d7ffc728cf6bfed68dbbe80ab72c2e5f445feb49dba2cd9e855ee9418ab0c3e0ab6da3fe8e9a694bd5155cf0284c13c7085aa7586dea9d37d51d3f013cef0846eb2da49e9805f616ddc5c99172ed0197e9c4c588a6446bcf769348a92b06701b2d656e43ec1b07eb1f2744e4663233ba5e717b25355a71c861467928114394654ffbb923eea378d05038340ed2c15a7c3d58f798f8dc42a27e3a3b19e9990416f0ccd6173fc8d08d5ecd7feeab972d5fbcc1280a10456b870e83270e008559e272b68a346d7bcdeefb56d82b063791e5883b63af2d7cc0c86f47735400312dab9971b75f
+g: a8ee7d86355ff45010f5e0545b90791aa5bfba7417b3ef49427410733ba6cdf724529317a520073ff98554252e71da2ec105331d5c25f159c3c69752c4877a803b821d7e5ab1930cd0709864193b78edbe3107155a0de75ff16e2041ff6bea2ccbcd999617b0a04b61b5bb1326425212d89069cdf7b966088713521798d11a95652213cee3dfa3703e220deabfaac1154b1a01c61850f7d4b80c333dc6752445686c449fd0c97eabde0d573e4e5fb6b53ef982bd47f6da4e298f2c524d90e58339448fe0a9f4f743061eff1f9eaeea18736a21c84d8b279eebb8eeadd0a18dd9322d0acf488e4d46ff98e5e16aed18a73e299bc424c9bfa2a0921e24fe980d1f
+h: 200
+m: f84e9214f581991dfe10205f7a45ad8fcd77eb49d9e89efe2811622a701990baf9c20de6111623bc255cfacc52330b8976ee4cc36c348a15480dc4ab56f4506732ab08ed7690df2f0346069d0a3f129c8e13d9a9a31994e60d248b843e73de1702c4c8c578ac5d8ca95d12eac270a9526dd1c5
+p: c5590e400e8af96dda10b398c0cb8e1e704d9b8284344c19ec97375f490aa1a50592fc3009ec0b006dfde3f0195488a807d17086fb69cb3f33413a759ed964c3442a88112abe74fb803dfbe89fa8f442294ed929e113f4f1fafa0ff62d8ebc456f96a5bc1f099063595e2fc35ad49d973214a7e04c3dcd28d7eb5337ed769a387ef543b51f6f763bfca4c308c0768b4fcbcee5d719c54f0bbf9ba51a8ecd711bb63a649187d108f69f9c9d5932ab5b8624ba611b964639d70076e023b40db6228943446477c174d832a2094d6cbe5ad57982d6b3e2fea012b81fb4cdbbf0307329d8f6b596b08332df64c9193239198579fa83c1a1083e656fb88b80736ed92d
+q: a2b512968bcd4c30899a63f0c9484be9152b86f5e4746537c9da6cf6347df7ab
+r: 65a04d3513cf1e452eeb0aa98f3c2c19d98f423ca7fdc71c056d4e22b9595ce9
+s: 9a478002052c16c77f5cd0af2a01b5146272a048af45b1a4a716716fe20d4e54
+x: bca5780883e13625bd340501c3ab6eb337a1cf5c9b5bb6c660de47e3aca1973
+y: 6b3e7dec84cb76b263b3191b3545643e75296a362d90750c58a3701ee293a965068998fb4e77ab251b7c10b32a63b148ef52479a777c52567815b8332aa27987956d5e09da7c95a38b62f7772bed147d9430155eb864b437a7b30a63ea202af610d1f21ce00fca89f0ad1657422574dba5efbd21d98a85c1345abe02a3ca9e776e934f2fb452eb13bcefe9673535f6bf00d1a0e4a1d48f6e537caf335bd9b1275bd2357137c308a6c03c2fcad88bfc21a6e5cf1eed713e3a811e34814c090f9a1c89cf97586015d2189501129ac37e5ab6f943fa6124a3e0a973772166daabfa0b53cdbd216ae464fca1f4e04bb8bb08072ddfe232f2b0a752b3778eb7d6beb9
+g: 955ea1e83cbacdd7d7dd58af1c1f2248189aad2d1d1ce85399e5ba5b9a7d9ca464e588a736507505d16c0f334316314700d91ab93a8832df95f7e9915f03cd38dbee5024bf9c18cebf19c141986aa345cd0d256d0d468ed8f8542616e6fafb0c8fdee74f8398acb6ea7158aead8b3e043dbb002276296b1b3ad80ad0ec499a475eb34fe66a4697bd16cb64adb754b87b82318da3570929ad89fcae1e40665c65b1c195a919a6c5cff87fa5fb198882926fc6766c1c1aca9a23ffbbe07d24a9b1b5e6d1f6e3b817af23c9c0bf75177ee318be80aac2f91a8c6b4a62b2cc1acb1471d4d53777e6cca2056daa5cb18b311113e87aed51565e9128b580ad41c00ec7
+h: 200
+m: b067eb82dae3f4156f6109d943cf5896d593c601172cf44f9db55a8a53a4a1e66bfb3b4aa5f9b046749e98bb4f62cfa2c6fe05d3779fbae6271cbc413d7933fd41d9dcea7204ebc3583a5535c01246d17c6674477cd917e7ff1dfc8d3fc3722836295e8fc0d84035a592b7a3ee3936a08571a5b71a6de477da4c1d7db88c0fc5f5131e474ec0a8fddf5aa5a8ad8d945cc75e940dd21e568f758f3a8a8629a243e77f30c00ed958ea18bce0a94956c950d5f51c593ff83e87dd6bce434ed33ab902f689d15e24b9f04505030ca5783cec74d253ae3862b2321da4f06044a5c3c4c0cb1772135ea8e873e964633cae07fc638b12932181c713208539ce461a4d
+p: f395b07d434e6eef24a81e59d5b9e0fac0da9e778a8ead10e5613daeaf8a3174e8d2d50c6e8f1a85bb36fef5094ec0bc52cf12a35594ac237cdb22809a3c7a88b9547e4377c616cccd0d77f2c774f15e0e13917ce20aa26e789b07b45242fd0fa129b6db8c8f12e92b6c9add5a5e446482fa99b68a75009714e1fae7d7a7c3e72fad368506622815687c964150f36cbebf077ef110004bdff2064e50f66a4ab283d9123c25ca5e3cdac6589c31d45317ee53d3afd5ca6506411b1d24b00b639e25bec45c78b3e1f4cfcba763f277c6178213da178b1da81739c998072c1d7dde87eec1424530c7eff87045f3e9f1aa252d6559b0eefc667115103db677984561
+q: d0550a0e3be4378ce54348e5a0ad58076262ac21a88387c4b661ae1da5c62299
+r: 768241d35a5f83567f5e3083dc833b1fe0f43bf55a8a594b22f7dc0eebebfdb1
+s: 938eb76774f7bcc8ee5ea9961fc79750a6c8067df66b8fa59fd12545fb42f794
+x: a6ff50ce67e7afef046db6152455ba03a2b13d314ce32947dff192113ef7de46
+y: 9061273d4d5c665f19a53c6624fb9edec986276eb4ea3973aaf1785464f32dc7c1e77e546088c5cc4574bca14d18f8eafdfa372a75ce775e345f7260977fc06436681ecdcafdac16a6d97e8df184163b29ae9627ed0077b9e3909598f88b31fcccd1ec7113cd2850afa351557877db9fa05b7e972fb96c0c244423221931e4d7dc9ffe9115e432ba4d73dddba6de23953318ed7facfa80f6b98f502eaaa838c45cc0da6038f1153094de71c618ed677c385fa0711b1a5f87fe33795b60d1b8fcc22b0e2cc1f90e8f2932b3de8c0449b7043c70a9f0ed453acc0045d3dc9492781339fd645a39378d9c4c4ad2541a7f99e52a920609d162db8549fdb4c56885f6
+g: 4b8d16880d812d44eb2708e7f2112f86effd61d83a6eacd69b0f333d5bcc7d4ccf87706dc0b31b85272a6e678c78387fa37b1d48ce4f8175629dc641dca7963cd1bb62abba521f47a998341edb99eb715258997df8cf0af4c1bfadedf45d38bc66907104ec8dabb12ed31309e97f134304e13ff645357b68af1bb5c3b234c6748e2541b09071b92f5031f1606d095242baec9e5b5718edcffe9abe3f1c14708bb7f5e6226c6021bc2d91155dca2fe5886adddee0836f9d5db905fd41748f0700196296e51562b4a5419b1b97bc58bc41010ddd997d843492bd673570cb4df4453a0013c6d70bb8abaf0dafe6125ba05e2c2ada9eab2f52a087e7d72ff9d69bd4
+h: e0
+m: ff6dc39371606f56bf5988f1130657008f1575e3d58d9a44d44ab5fec9764999694b320c7f227253c0bc5c4bce6abc9daa7a9795b743795643a5d45404bf10b61e952e3c251d668f7b8228f605aa55cab81eb553934e47e8f751d5a7bd4ad815bd385b70995457737b1ddb72b5d2e1859c75ff59b691fd8e45240ac6f312dafb8f7cfb54216d16fe390dae9decb84768427ca1
+p: d67996182cce04abb649a3dd90249f3aef162a74b19635689890628094141738e9ebe7f76e1a8f79a1e49e2c26c8eca952eb08ddc2ea9032ec3fa32a9ca2c865941b3df615cf6f0b2c48cd91b3077e9ea073156378a59e77b378b8e154e2a859317dc2c939853e491425dfcc503916e9ce8aed4c3dfdb2e895f03229ce6de6a95bd4b32eaeb42b5151a35ca18b42b6b25ce0679534ee2177664a355981afb6b3c6d2a9dcea8d07da444f670600d72e161c14560e5ce2dc58cbb3f053e08532f58494ac3871953e09cfd8aab398dd22b95f447c30cf2be164991f29a8f6ab2744dae784e3834cef6781a4fad4bb598854fcc2df45c857614cd743baeafc4ebf31
+q: aea2961c67b6833f3ff1d484edbaf30f565fa3d2c96518a848c5a0eea288703d
+r: 6c1ecc8e508dcd5882d85945c2ce16f10171eabf77626f47296c1141b691bec5
+s: 184f7a4fe22bff5d5a7c1de8b690906384b1e3e13788ec9c4c1a944e5014d6d7
+x: 18d3156c20c681d6ef0bf0ba5156ca6fafef278fb6c0a9f29633fe849d8e657c
+y: a1a82876b28ef5ccb45863b6572ca7b4e5670e5efc97446ad6571de248ae9e482d6c5d61914a894df7b1fc8e49d6f3df9ec7e5a1000e61eb894e6e458cac4c7baa26b45a3afd10857ce0f0d689cbabab991bd7727942d9c3f3918aac076686ea769adc3015e138c16f9564d6828aac58045a0cec1a60fb1a58c7acf9971322253f306429ca6794c4e96e25ac5766a86f8087bc281f925e4432642b7e8604a1d0f1cb03eba5e7f7bb64dbddb2e5d2ddecfcee0adda175761460a1e8e363c995c1a9bbb5587d5b5c91947bf1f1b1c0094ec02e3c66810f39089b7d78b09baf5d9636ae5df8766627613b3bd0779e7997cb938fe9738c4e6c18db1a53532c386b91
+g: 961c5f2a8db735b0ada170aa44a959b29382bc65b9be1983874ce4b975333f4ecd2fa2f3f070bed88e367ef13efc2b7bd6f9661d7c8530e43854f702aab72d04aff0eaa5725a7715b608292ad47280dc97d5c51a927b079eb8deed615cec48fd1f6d86813a3b603c78c98dcdb965539e0ace275ee2dda588d6fe2efc360a47319f70c9817f684260f6843e1a790dddaaf3fc9388b46f40ea6e4699d1a5a06ca1c5ef62d18bc044dd80b746b741042d15b86deeccc324bd6259662b8312a73761b83aa06e75d797f48015f45d04c6442ed08dc84918ddd036c1b1bb77c7eea25eb0722076026dea7b0b62f18287680855764e4ece0137f63ed0e51773dd7efcf9
+h: e0
+m: 19e4f67adc36872e8475a30433a643ec498c8f26d24564ac8945408903b55b3afdf486049806278c70aa3394f07a6809c6d37bed8a3fa078b88570291d0f7b07bdf3e87c6aa89963fa2d28dbe436c4d1467baa7b9e760ca44dd7225a991fbdcb1ad8555cb9a8e19811a7eeab5ea4c8e17ce47737fa7e41e5f125dd72d7e1f8302a829b316eae02a9f3e6822d391b8cbfd82d018326df0ef9d3ec27fb8fd75ed38c366a99354754f96547d781234ee8b6c2a7c41a4941508f8948e05c5fe188653358395ecd2a1cff7885b1bac810b15e5ba431925994da288c8a1548d69b626501532cde95
+p: ec4d664b0fff7a282f453df4bd4f36acb3d69a9c48e32c7b7f62976aa79fdecfe9a5b8653a36565526e3f6cfb1932e1fc34817b2cda740c46576c1484758bd7f5a7c5728201544fb2324b42d7a5589e6d10f0bb9c9233b886fbbe699b8c6d364ce59f44cf62d7785fd392a05171c37850b93a9e5eab10dab8727382fbe795a16d989853a13c7ae691df9694ffa3c19933359c47b82a4d3848918e0e7cbaf596205532f202bca2106eb01c160ff8782ffb286cea259d10d7a3cea457c64fb8d5c4423abb9910544698ff60cd285d37c6a75c55c5686cf198103f081c9fcb536cee91b233bc9f15b8291949945d8a0b62aa0240426327de5073546ced39312f301
+q: e0cfd88fe31977f93db91de0136a060d5fe3fddb7f6934d46bbec18db6e2eac5
+r: 4e8e2668572416f06c45881916aaba41bf688df9236051425e38690142eb61cc
+s: 303bfe00d19ef5b7c33279e010fd83bc78d8aa0ae00fa01c249d89e9c440bf9a
+x: 9e5aeeae3d4d53cf906c6389cd48806dc6d78ba63910ce4bb9d33b9db6a7981
+y: b7bb1375387da456fff61e8005b7a37ed47b752d29a74a424e004a1cdda85a47064f1cb28a763052cf142b76710b539fe8ca8e71fa4871b7ca833ca72a9f1915978cdc0c8ab2f12116ae52cde5f97274cd08f1b98ecc12a9ebc9b9d8fec5926cddc05553640841c7c22187f11eb452f62330e2bda98eec8a7e85c5b01c7e014136969da3efe1ae3e8bdd2686e7b5b0464c3968e15615ebb4a117ffdbbd930b8467ddc627a19bee0cf9078cbff694838455703bdd94567262ead49413426a4ffbf2a569a406a3fcdde5996efa75594b75d62029e10b532f7c0817b49aaf74690f3432eca8bf98c055ebbba7de03bfb8c81ce8c87839ee8ca3dc2b8a5724a13d1f
+g: a930d5bb8a2d6b1a6ef95e6fcdeed2f0ada13015951a2942b80196c78ad0c2daf92cb1c80e5768ad746cfaf817b0aa7aedbb0070219e89a972d964fd8ae409d63ed0f296debbfc2926f0a865c7bf8ae7ff700d8c3f1893872c44261b7779c6b086ee8924cc7a9eda73effc0f694922a0ac2ec10999c91e1a47557b7d6bdfa267d2a38a435206fc0d5bb47d97176acbb9d1018b001a8288c9a3b63969c106c10d79dce9fa41ab4810d4c085ef7adff7be02a15d0080051fea7a18825dd97e82145149d5dbdce0b8af1cddf137a1d536729838c8ac9e88d946c029d3eefae9b3e2c0ca66f2f5d7ee249335f648008afb82a9d9b78f08cd08634dc17c5dd202d459
+h: 200
+m: 39cb6e5003b73ae6f1ecc551c6625154
+p: c8062eee734d2dcfc62bdae9b864306906d77adfd71afe18166b04c84e7cb43959a231c7400d37999288820cbbc51d3ffd6f2521eb51e567fa02291456fdf61ed6a6806c4af412919b1c420fad1068901d7921dddc02a14243cc1399f2c931648717f3a55a28b213b94dfb45401b46d4fced9ee83e54e55b7c27535f8e7ae2a148715f54dea531159b9497019a322e9838cac19b8684edb15d4a2432f61ef241e5cd5f20d1ee0828c84db02329119457ff05bc5b15ba279f9233a1c9496ab64f743edb41e6a0bffdb4b3b52aac58eee659ef2aeadd2b1207debbbc47d606b3948b937b2590e35b7513b0837cc2e86c2aff06d0fcddc4e930202f19f9316b130f
+q: ef454da53d9728decf112d714afb9242f6231632f86fd6373c30e9e49e10b11b
+r: 3ff28bcceba7989a9832f8259b5ae1ceeb9eca73d0cbfa24ab4cb273e64ab25f
+s: c87de7445127dcfdcb1194668df3d59cfeab327e3044027b099f2566b9735763
+x: 88f1922ab190a7298c95f663e3cc9cc118e946a2baafe137ef8a21abbeaaad96
+y: 398275d507d4ec7660fb3549ba0440a7f742227f42268dd07c01bdb67064d39522ebbc7164d274db4e79b6b6bdc35bc46eac51947e45376bfe8914ff5f014bcfcf219a2606dbabd59b8a25270d85812d8af35e4b63f7a19ca7566ad9cd23f931cabc712d80a06f89fad649f423ddf457fffdda4261559386bad2f350465090a626cbf5d6749b2473a2958888a7fecbdfd2a16d92ea54d67a75088be341877438eb4e92831898b4cc36118bc41c4235d31910c0aa4f731058d9d7fcd7741951c568c1342a2e92fa74b8e9c8c92786ec83e02f92e3216f489ec1f7f6c207458712841557eabc87d79b896a85b01c6b0e1dfbde4c8bc48f451f41aa38c17a7da8aa
+g: 23d743706b16fa4684c9d3021b9ce528010f584f62c18a5532fb828b866bb17614c63c8a56c5a88cbbbaedcf9ebda81ee9fc676ee4a5d16be07421720365cd88efd6851ac97cf77c2e2afb014913779d7affe3f8999b01034128b958108fa74c0521230fc928f9bd274e30bcae3b173e971c527506e7587fc8a597fbaf92b630233b6c3ad5eea37098b5dbc67620c3fc1dfe5b709b26f6267057103b757cce3598edebfbbfacb6efc396507676af8ad8938d7f965fe2335e9d82a1229212bdb3eb9485af94787c68f9bae9a3e6f0cc8d46e31c432da59b1764577b911bb9b3a5f181954fa44c7e02c1d64a0d4abe9cdedcfbefc01c4bc8fe89861dac43259c2a
+h: 180
+m: 00c97c21e666cd643877
+p: d2ea8cc1302fe090da3d5c98bb909313b8e1f0aa1452f17782e939412b980ccd9aa76aab8e35abddaff432da0b0543f52b88056f5165226ba6a5ea1b168a60ae69e5d617fa3c9c492d92fd736ab3c49504c987dbc7678512fbf3c6a64c55bc0fc76c0009ae95013eebd2698a48ca3570b7d9b9edc268e12d6214d4bb6033de2109ad8c4f636c129d03c43bf856b08af9ad82f1cb4d1f10c7f61f0add1a3fec2e85050015c6540895cbd03071db7bdeea333499438d73d22c32f00465055990d2a2d2c4050371306085854d2607c232a0401cb6580791e1fc8b6c28c659e2abf3977a9c686261b517e1687d93a659bb5d5fd9d9aa62aaad09a5c01c2191b148c3
+q: ac2bbb7b01c286e50501047651860c4a9e783f4e326de6af7e0f87eb4c30fc07
+r: 996e6473c06c9350f2d4270177391c7df361af2fdbbccd6f8f869263f91bcd3c
+s: 2768364708a5f929ed32ca0ac734347ad4e8b773b44ea770ea60698cd061dad0
+x: 429c4a24029957cc1b47fd219343f0732f254f9edbe80d69121e086df973e30
+y: 2c5e043bee62305321a1bb6057b942a4c983c15499560d19c93e7e3707878b1ba0a6abeb090bc46b6255ceaaf9aef23603f606ae3886fe7d303297bbcd38abcba88827010b068825a6dc59b3a33575987429e44eb694deffca26c07f93dd038a38141fe0864be1808679d80c7ef709a6776b51e34b65884e43ef8884e2ef27327acf07ebfa34c6183e604fd849f0b15ddc4f33a56d33cb637bcd05213477fce4d451c217c5a27558dfd9517cf5322737969f7bc83f7dfef81d34223504f044013449f1259d8ee275d7cccd2753708a09d447db89ec42abd88fc204ee13bb1b6ccc9f535fef26c90a46357c922598876488c8d4e145e52bbc5b50f84f72b12f39
+g: 577c75aed2fbd82c2dedafac1a45693147cfb45faecfdd077a10ed6ea0d40e39ddb62d568d73f5400c45ac42df1f2623ebbd8956f23a35d7d149c559b9d03282465bc47b645d7ba7bb4a5eb0dea01c1cc3637e7dff8f148e781450fc12625bf1a20cfb029e33785c4007a9888ddc7e35e50ea9d2a0a25920851bfbd37d959f3fff1dd7a236de07cfb6360fec44bed1c59af1db2fbbb9e6faa2475ed0e49ef7b9434e54f18e7401a1d80dc40b3a8a436006a4d5a9323247a85bdeb50d00de6a7050e61315eaa4d6e43adc067fd4bcfd3ee01d7af9da72095eb1d174772080ed9618ff34b988ba3fb6019462ffb9bc9f25cd2e142be39d8d47ad91bedce1e414a0
+h: 100
+m: 831f02072ee5daf47051957249aacafcd0b22f73ade72b33580e2a18083b5a329ffed5b9883127212756e63c7c9daa26e92411fdf6d06480bfa0d5a3acdf199e0e9db3ae7e4cd2b40dcd7db38f670ab32a4273d59dabb68055141674e92c784500606e04a63430d564a263d2914aa2d13c5df443bd77e785c83403cb4b14c3e1c68d8a0fd7c4fb1db07bbc7e43b1767c70632b216032823e2e0eee310122005430ddf028b695a6631a663d30653cb10c5c489fd96fcea3bae9834018d7baebe9cba0e4d5572b2ca8f075038e806a3aa2c44cc3279e82449bd23ae04112512733ca2f3fadb121
+p: a8eda33605b64654d0b8d9bed1d6481e854d417f510ada5a08955ba0b212aa70317528bc204fa012f99fdb1deb8f41282c0fe425bb06bb9f5ded3963f75e6ff96802cd2e7aa666e9a01d6a7fec9c2b2031d8465e62296910372456b87c0340dd0d50c2bdfc8740ac4ee3958028d757768c90520303f55ffc57bc20a001a27540efee52e5d436c055f9bed0af613f0fd8714831c778270a2ba2601ac920eb9909cecdccfedcb670a6b218f358fdf5822efc15a65ec221021cdba76334511894fed6dd86571a97772fffabc3a7a19a54b9495a724aeccb91d7544c172ffd3713506f3b8fdba2a342817fcf5718d94699db3813ac2a684f4aee3a38fcde27012753
+q: d305b00be079018cfdb72cfa7d594cce921dcfbc2d6651b8acbf0a7774c5d841
+r: 9e50e9c4f9fc9f9c13ed982931b31a050d9bcbcbf697374ef86c85832dc0faee
+s: c8181426d369dbf58f4fb0b3b2d01e05ce60d1cbda09ecf7be12bd921d901189
+x: 7af19ba5541ca8ca9c449789341883528da2bf64ddf754439b8d30a527045dff
+y: 605c836a8070ba4850008101451c38efbd30ea0eda6770a4b14ac9902fb85ae7731a1d5e52fccabda1d36b5ca3ee821a646d71ae075f80478ef7894239b6baed488474d31e2db2259ab5896616c0797a1254d5b2b0ddec63f408f263143b109ca421281adba13f3cfbe80bd571d52f621a15db04a18ec19981f5166c08e7f3fce94959a2a491662bcc3f0b8b7f6adee4338bc2ec2b4fde960af59c7a8d7218cfb087edfd853efea2ec2558ab797a69a1d4fa87728b54acbb438392debcdccfb549b2300c0e168118b9380a13b979b19c7b23dc9dbc775ab34cd262e917953a157489f539670b8b65241fadc8fc52f644c59988d466246ccfc2fa88b1a81d6abe
+g: ace69194079c7ecf821fff3a0ca9455b6e2e105cfa090a82730279b0cd6099f178dec11ee836219168253cf5eaf689478e55f2901e31072b1326aee96e8f4d7cec0b2ff6017e8fdc6fe0572eb85753eaaf773c897dce049971454f8b4901a471586998b30358fabb622997b11e898d002287177e759ff393703b95677ca21266a06c2fc69fd50a7cdca8b32197b0b90a687f10edc1dc3031a34fb8ad88a4709b783b58465e6fa5d16d12b88aabe227dd2e8bc71baf829fe1d49a042e66bd3a27404417b686b6334bc53c76b6482ea8bc243bd17107dd4d535d570042d892ea91c662ce2bcc7ee1574e167e95b2071a3190564bc0d5bb7e934d60d4b7bbd66857
+h: 100
+m: 42e8ce93f11eae2fcd5dbfa4c3663d757ff9f8d4d507a25e3db258b990aff52fb7cf9f95bb7a9c195d6965fff3cf1d9905aa4499868f7ba6
+p: e1bdd4669c50812f22e39a8a1b6afe353f33fc0106ef73d4cfd6eea8934125bc92f3e46054ba1e58d24913599e65859945cea7c919419fd70be25202b76d7ebf78d463ec5a1f2ecf22c83552b05de9e74c0b4930e4fcea347653ae06b88e660e16aa339a87599c1f187113e0e1717bed3d71e79c54b01bac7a76c6a1e680152f72d2c47b954f8213b83ca2ff24d0a5a5623289baac9d3ad9005a00b53ddcc19d92167ec3d590a24c8dc91f17111e1a94daf084581b65a4935af5ed8933a2ad2a323152100e26ad5a115f828f2ac43135d356076051c4ec37d81e0978437f8b9846231d091608711dc7bac4ca23da80e27d8be8844963465fa8e85c3f2c6db055
+q: e2b7f96e822cbbaaacd2eb9e7670ffb526f469c861ee1ba8263132bdfd5f8bcf
+r: 17fb40e8ffd6f2609d4733ac12104b9281a6618ed74ed31da6698dd7a31b9d5f
+s: d1d68b2609328257e58da88d21d47e3da808a4901a4ad19fa6b767b2982bebf4
+x: a5b2600d0440574b36425384f7737786e481fdfaa20bfcdef49f1af415a79984
+y: cea577574fb5b78f74ae15c467a7731b2492a96390ab6f8e6ee9d321ee09f5fe014d37259f09889766063be6b4367efe9503e2bf0f9789ccd78c62ca5e34fb9dbba6a7d29a552904310ddae38960eca6862ddb8dbaa78a0e00e0eb56ee1c69f43c1f30d9a2a386f3d28986816f71d6ba8d5fc8e4f40aa9e7f826b1577807f99538793bcd4fd3b3099682476b422ed62660aa33ada1275ae50e3d47308fcf5f8c8c4c991aad6870d4f7e5a142e006c27fc646cc0e4352cfe4648208cc60a4e89e8905c862cb9e17586bb4ef2bfeaa39bcbd30b62a194983edd94de76e68c83984bda6561c06ff3f9a0855efeeb2a30a47c83cb62b68005976465dfcdb12874b5f
+g: 3f2028351d454975a3f6d02b04cb625a742cc52fb6c7f49d1c5f83616316918655fa56e1dd7606571556422108fb5e5eb3950e7062f105e772f9d0840d1944184fcfa64c3e5cb590b4d226f1b66b63a423a01ed43778aaf64572fad67ff079905ea619271b77dc1a5a57e8751b07a180ae606287f1114ec4671177ab005f8367cd4664fa07a48ce054de88bd7a40fbdc10fb3b950fc9289ca8bb68ce16a4a2256dace7b4c5b430b7a6d17fe5983b1429c04629faa14d73ae3528b926c8d0144cedbc565bdd199aa397a977771308655819656cf6f8aa2d4ecdddf0a3167b984c3ee330a178b04b6dcd4eea17063944e80fe1d0a1e4b69db9442131d639e8722b
+h: e0
+m: a9ee8f4f857d
+p: c275bbdde048f8a42470c43cf08cf098a413725f4fb3f1a4813b7639e702197e8d3eb1b1ed1714271718939dae8be9d1d35b8cdb255fe51f2f99dfe9dc6d03039f9bc5b805b64f943ff843bc0b9a913f5d197a5017f31a080510282db178c0d14138299e307b7e8a714e89ea8ef56ec04859c6b8d91e723e0318a4d60f0321c08481e7f3205e3e1938c4e0ffe0336f72d2d1caf309654639567b14658c96921d1e5811c09025e4964d09e62dcf929f7427ee19a98214bd976376bc2510e1b0ac904d25d5838b99cb7556e3521f02497445c2670f537e11c5e548c0847d332fa7a9451ff9aba0686618ee8e9e9a4d6c352eb73f10528ab691d68d5178b52cf7fb
+q: d288fd8335a1a54378a9372beb69996ec7a608eb7c97207580291c0e403266c7
+r: 17794e7d3b529db5132c4b752526fec1301deebc7fb47838c92ad571e95af99f
+s: b4896fb23af45c31559b8ab9798978b89ff724430c09c21a66f58cabb6cbc5c8
+x: 71a0bb903f406145f8204b69827ecef2e542b82cf08fd3e7c020403b4582fc57
+y: 51c8313b2731fc50fd99d4780912a3ab86ec6c2fd4da2ca38ff994cfc7658e2bfeb9ad10609944d5a5a122d581994bbb0a523f58985cbbb8127b21dcddc26f26c239a3bd620f55bb6fd1dce2168e21861025afb4d0985d0399c3c7d8cc201790fdea160e00fd0b0bc362e0682b1982f875d7ac68ea4ce40a145fbe1f0748b13dcb67729bb95be99b64e6ecde41ad66537ce0a2d99db96222c528501e6a9e858c5626309931b5d0dd95a62e4ae16fd5eb7b5131994392d0fab16dd4d935e6dc55c7c85b9b6770d288b26842885dc45911086bf495df8d761f7a5755f9a145572ce0952b149f4ac7b9bda398c9416a65c89bc04412955315e08eef7b696662c19e
+g: 7406836a7c0178035745400470e31c58180d0cd841c4b9a814581df145bf2bcb062e42faf7d3a3fb12fc282fe01154b8cd36dca6d4f6044fa6814bf660270ad2251e868b3051f4c35a2f03d506c5d4ed147268c72326896d48e249303e32d748c3e8b3787df76db62eb2a941b57c945b95fc563bb2b70a611df9055a2a6bc04a5383f7963708e4ad288573f3247051d2187c2ed3e033dc800bbd0cbae28aee5ae1bb0d65b2d38f4d053de952c63cf320c0964e25f83d69054e767517abef5d025b6535ee1d4a06eee4f72c0ac957e8caf667b6525f0e43a204a9e889301bfd6d2de594206764003a2a197fb48da1e75e16cdc3946f8c6438cba0db8bd3933986
+h: 100
+m: ccc5419f867ec3b2528bf7f77e16b53684003e91ceedf7f0a392b0d8a5b0cb69
+p: ad9bdf1e57b3753873bc919cb3b9c5d6816495ac8c1668595fcdc5b760d1c5aa6eb6f0d6f865b759177bb25b17dccff6a18be59b3896e24db22ad9320388dda291d86931330cd76a06b4a50f73459edbbc553e6350b86515a79f8a17c2f92050db683f88d0c21e332ed04660ed91b976bb5ee47a5afe6be33bd1d4e97b7926ca76dcb7517367172f5f9e18a06b05769cd21100dcb320e88ddd45435b41fbe05be9ab2788a02ed46ccafdb95e133f4472b2c3d052495d15513bc3341783ec458e826685fbf9996334489fdf8d2e540d15fe861e6dec623ff2a2584c041a4182245ae4e100215c74e1b82ab40b0b77c1246681cc5c2888155c237a120e54dbc9cb
+q: 91deec60a3b77dc0e867139eb8f39abd2a51a2b4ec143b9f58cbd17ffb499577
+r: 229d2953cf39940206f51eb22de85a6de54191afae84aacee826d660e992a357
+s: 55acaed98ba90aca72e05ccb95d37c913e7c03e32af416555b5338c24e37c7e6
+x: 7bdbd64c954610f0ebf510be20087126162abb3ef375d6b6183b33e5903589a9
+y: 13502f838272984bdf9914d8e02d510a596fcdd1809ff807ac847943936c5b258d326958ff03a451b2efd09bf09fbaae26400215601aa0cfde14649ae01c1b03818434b225a743e49cb51819c21b2b17ac4a342d514d98569c36022274d7c999b4a5d5ccc2db51f42c367a36cef98f23946ea507d02847566ffa1fa379218f52f5ccb76c3ab64208c6066510066cbff8346ebe6ccd3987ae6bf57539bfa1645e0584e69b0e9b09a3849a314421427935cbd9e4b063d906f3bffef74c0350a95247da2a49985928ee2f4cfbcf512a5f1d081020a0a7963cc8240ff0b5b5ea0d99a716d452df3518cecb092cb814bab07de668c4c5977b7ba6652952b9978bf1d3
+g: 51f0f54e4a4e5ee6ed696573c8cc9166976d299f077f64fcace342832c02e699d42e26c9247167b0dabfc7123906d515335d76a272cc12faf41ac419edd6377916663bfff675e246f47038f3b0b3c80fbf5b20a56072acae5a868c8662b7b4bece9ac32d025eadbd4bf31119060537c6422df93e2c67b51f0a87deedbdd01199453527866349bc6f5665dd6994b9eac9b605465829676750affd57ac63e339825dfca541b72e27c6648b733f47fd7e0453dbf174e833ba5ee9d84af2bbb14fb3b6cbc333d267f26d2f25e84fa4ba3414afa41c8539896d73b7f47d8120b9bd08aca5ad323cde5673aa7da7e8b5d1ee9d45ed15695aa7967dd2886f52afe42ea1
+h: 100
+m: 0f95ff3b97683d1d7fd07ce417e49a9afb31e090b1a883d3051cea76ab8871ef555b8ef164ccfd71f0304275d5adcac2dbd647243250f4736f7f7e76e6203c5caf60bbbf28122adf71c0b1e9327a8478c57ac2d6e3974a14cef2e2720d1128c9d1da629479d999ec5fb61a1332ae4be25cb8bb99d9c3c73bb9b9e7635e80dbb23e
+p: a742043496a622ffcfc1fb47939678867bdfca54e3cd68fcba161043d7faae8854708506b0904096ce6ba7d7042a76a5be9ac5fa316e8761d49effb83c08c6765cd1a6a50248ff804607319a31ee3da393eb4b6b80347891f255867f00f55af2b74b8391b05b6f74640cd56359616bece266dd7c1f1cf1eec0787f3b77fb40ac718fab735b0a0a1aba0a4d4d5669769afd10f77d77b756f2b7c841e13458bf89e7bfe0d9691c7b387961fda8f7c56119980fc4d92a9f6f74fbb33f20f9a1a91170af04b0526496e3a374bff44ac25814f0afe8f50de0c835703170695cf8d47a97d0848a3a0f00f4c613bae5795b45ac002d3f6dc266c1f64d51e4df2266caf7
+q: cc8e1988d4d3acc4f5ff515e0d856acd69e55568952a23f41507c73daa33ad51
+r: 226f796fc7fe4a13a2a681b34cd2923fe0651860a906d2261fdc0c7492848daa
+s: accd4cf3bc38d358ce3fcb8217588cd35d1e44429f2b0d06277fc5c8d75398e2
+x: 8d18a6fe96df9fb7e9e9e06d33e7fee9b6954a1034011bdc223a09e4727a52a8
+y: 8ee4e1576c96575d9f50a3aa7cd6d8bd6f2a4df2d87d3b638c5b7e2c3031d54052d3d2a9baf808d72ee1d9ee5c5fb00361e3d3f7a9c0444835157f3e489c8394a3c4c90fb1b4f27451766c3702bcb3b0d546d84921188c1aeb6ff673a155b7da9078184204a77b81c46a53429ae83e9c1dc79fbcae4d0577213c5bd0bc7af1fc5228a51e2e2706919e70cee56aa214d244a560280d5595248d26fb88f262fb4b033a30ff5c2c1528e98b18f48d9efb457df983b61d247a4dd2e47a6c697f99945873e72b0c712df8a3f0cd30c6a04e61f722a75c03bdcbadc3565231ec28de8e30f4d1d026ca769e171f44ac08ef246e83aed26b71c0bceb0a6ff90059e4a4a5
+g: 84f81c3b2171f1d24f757681705d73c089c6914012a1590c8163f7a40a5b7f04cca8db0fd573e7adc2514ec38cea5fc53e8e0185b738ffdf6e3ce2d5b699746010cba34897020dfaa766b7c00e6304c7eeb915204380d8e925fc3293d0fd0293093f6f8783a4cca045a87c090de79ccd671f978a5cd8fd0ba6f333bb27f0d0a8e2086680d0e0b328bc2367556367e042f35408cb48a5c2190d6f273e1a16f76d4d5fd5a151b6bac6f80cbc05c7d4a643494b0a378868f43e60924d3274da744987f909a820ebfa36a3b5ef03dbcfdb00406ac837a639bd949d3e47e2e3a81cfa6a90c22412505ffe0d0958a4190f29a2cda1bde50ceaf80201e998aacbfae8ae
+h: e0
+m: 478e7ce9de1bd541b46b472d99c9e3d326ac3bc97bebad93bcafb61df59498d26894d41c18562c57bb3b43a431baa5b9a64fa6a42189a9776757432346f59a9400ce2715cacddc7fd545b1607a7531baafa07226b4a6cf7ce2168989ddf633b471363740fdc80ef49d38
+p: fa8b15ecdbed2cd36a4af57b4b9b31c36f34355ba081c40753bb7ba7c593c668332ee24d7412f4b762a578e1eb9006fa86b220cb00c355a3391f132f885bb1f38d67f3749623b0aff954a2862aff1e486eff5c4a0dd5932836b9be4dd6827abaa96f7c4c76f16051693677281d717debd456d063e28d5442acbf15b93439bbcaa51bc9acfee1c17fb3bfa72bbd107bbb2e116cbc7ceb3d6d56c59344c78c45e70cff3e7c66e994d2aa04cb62b1c0c93d0c07831bf2016146a0063d49fb0fe7a291d73aa144f73a52a705d71eb1090a3912d7d8dc14ffc5f8f69f2c501a9d002c297d034b148f315067c2ee404b1f8a39e0f06c8367127be81cbfc17392bdae27
+q: 8811cdd48cda5150c19d7a7b81daba90acde023f885e74e2b6bfadfc7e219a77
+r: 1652a0aebb5767af4b3609eecb12ff57a062124761e58f35214daa7159c55af0
+s: 31853617c51d462ccf551b4d12a5c90ec5007449f518a82ee8dc58c1cd07aab8
+x: 2e2a0376d26ca8bb6e96f443a0dab680f77eaee87baa0879e27a2a511093bef9
+y: ed8275c783eacbecb164dc2946c082a72bc429aad3b087ff645d4ac265e2bde710f45a1c1e9a4184c1c8b2fb2315296fef6b87ab83f7687ff5f9f08c0dbadbf824c2232b1d50e5bd583848d280751c79973d1bbe7d943ab7425280f4b8ec948c1a67ff837696a3a6d470e03afb890bb44cc169a533e3ef1c64dbc60203a7a0196bd0aaf56cb78415ca3a99b9d98420a1bbb90e4080b42b41dfb55e057b35082e552f29d4e2a623d091798b471406bd5fbaad5ddf8733c36a18a7ad407e9debf53f534367411a952201a0276efd781355d52e522fa764d08af0cd152bf1ae13c90b37515ce09c0e0238c0b7de894cc2fbfc5dd0d5e2650502f77b3a256553d906
+g: 2ea7db78543274de385e3c277e5f4e3cd0768f26ee5a4f479cf310d6c3d15539b2afd9308a0be8d0d69f015032438eaf327726217d75263f92a3b0d833cac7ce62ccfbe56159d282a73b22fdd1800e87c1b8acdbfd6ed1c40dc9c6a24c3aeec10001fc3456ffa966ecbb0794b9f890320fad12cc882dedd80739c741e24f337dca727b975126b1cb07f058788ffa57a2a54c948a7ec8f656c37df380bd05dbf766196001115eb3dac84d436be287e612e77c9fe1ce4cd932aadb8848d5fd209a2940a77315e7ed4f133daffc38dad224c83b4d3339834646c982fd032ac6a5a7b1a653f429751af6b3e33a7e3de6f8064d83a09115eebe7dbb4d67291812eac7
+h: 180
+m: d3
+p: 82c3b47755ac0211f7cfa6aee8c184d97108a00016f46639ca1be9342455ff6da2287a0dc744d33f6ebe7e122bc57500742cf70c2025b963124f065b518b96265796df2cedfdd736337b9383a9aed90e53e1e2d020c58b5ff3665adcfaa2347bdc3d6606271865f033cb49e5a0e91d3011f22bc237e32026b9a6b4808ecbe937a7a39d073f808bca3d6644d8edb4b2419aee99372ddde94060ad4204491e719b8d8104cfae0e5b4fd1281a7b9b8e6d7238f965b5bff10728dca2c2a5c9fa24ad5bc1f82ebd25f243ca1cee64cdbac63c441ea275968c5bb5992d749bed0d47475e7353e38f24819a275fb5cce6f1997d99c9ff63b81cccdf464fe3bb056b0287
+q: c482c7e3faf442f74e98561b0cc14b41cacf2e5005055fe14d6440d53a19c139
+r: 2c9d6818013855ffc3a0e6c85e2a603e0c8e24738eef2ea18338136a48ea0593
+s: 71e2c35d473986401a5a7ee068ddfba31a5a1d0c833841ef42dc37aaf5fce712
+x: 797f4f061f4bbad13da298c9f10d6fcfad21e915e2a2129e73771e580d843815
+y: 1ed11fd81ce77c4de03a2f31185ba794c499ccbd35141a611774945255fbe036ee4c317c7f0372543b175847ac75329373458fb8ed5864c5e2fef037b30e6679f27e57ed99926a7f4527daf0061dd69fc12b0824bb023893840568b879db23f98091bc4a3daf0b0b48c1c766eafb73692c71f6b31a8677fc43f07df9d5c4efa254f363c99e50ef0c7a0a68060b38394396467cf3c9eb178577a12f6ad4efa60bf7c5ea100e7c982dbe76a2e823d775369bcf2d45677fb66c20bd00cd6caafe407a9882829b2948724bf6a06512ecd1456973b3d6e03551658c04463a52e45cb6c3ce50c2d223fa26c97915ad206bd2c8a80d2100edcfec065bb594dc820ce0dc
+g: 60190341f6a04ac03a9bac1310dffa2fe29e074eeb4825fe659f871b57424a5eb0a046c9b76f7a085ac7dc4752bf333b8ac54f35e650eee82591b846dc500c638bf88480bf177c6f1ce7144652497a393e7a9fb0554e67f1ce7410f862177026b7d993853e2edc83c7981ead33c728e73d86839d6ff4b10ee095b983020eb2b3507eea397fa4dcee94ca184b0ce79046d61794739784ff7006aa36b36ab6d00db7865f24dc41a94766dd53172c2ebbb23ed44dd80ade2384b17a8af12f088bdfbaf7dc8ef3f7b5b0be6f0c34d1cf260c88bb6afd66d7f45c7f2c7049639b5d1d320829916a46cbee2626dc15c4cc06fa302d4b1e0bcd398a4fda3bfe8ee4c66b
+h: 200
+m: aba2acce46d95feb5880b3d7e69952491d6d815c126b92dad051c6017e7960e98f3945ffd9cea849c9560e1c275f0f9f1fef0c73abb3f53f10c2e07bcc4a735637b7d92d0643ab4b205e444e911baf14c4a0e6c4f7353cba88fe6a2a418572c4cbc1ce99a9f8c9944f0ea51393d97d823f8a2db40ef04a78de342c3e5b166c2d070e4e4d1525358d5f14e5e5d7988ddcccb4700106764e827ed5795565d7a5bbd3632a2ed4283a9e6d1b035b18ce5293ecd2e7aca437111e16550932ee1d75be24b7610c4ecbb6989b95a5dd21e394697fd70658248188670fccaef73fd9e18312999fe760de
+p: aa8f94f5a49c956c1e5973cf89ee16d485884aa6d99210714d384d204a009e0ef3793806ff81cdc5f4e581cbe6afe3e2c8919e7fdeceb921b2351dce7edbec4acf6101b8df7d80affc40c07fb4ad126c040e7f75a78446c5796b924917c1aaadcac132348aeba43619c1805896ae8e96523ed513088cbf1b15d67c5410165824beee1120232c755b6751bdf3b8f0f9e4d993ce27d37a7e507cd1474010079106729e589d6a0851679d24445ad43b91a5caaa8f4787bff4872807330893884d6490d4e5439ad6876540d8b2e61fbd543235d98b885332c4b54d858b356c9329b52607a91e1417b44789b9693789cab10cfadb0541b3d29c427319b6406fb5d38d
+q: f4e120b4a58b6cce16abd1f7c238e7454d6bdc112db8df23da12a9336d374f5b
+r: 2d0f4808d0f4491a2c7684c82a22351cdd138c0eca331b553f443f1e763fd300
+s: 26a23dfc2881cd964b787b6f16c159f6c8e2db3477fa06d276eba3ebb6b4ca5a
+x: 956fbd89de1f4c44fcb67784a1e3f54a8ecd607599611ed658a2e80b6fd3e05d
+y: 62bcbad2614828379f3ca4a7114f41d0ae01cf1469b1e9e90d2629a601db12926ccc1d4dda88496f41bd113dbc69360b16e03ae3e97976924154ced4ed614e5e60f38ccc4613c918fe6fd8d6cb5cf7b9d9015604ee2fc4d597153089a1f25b540b9f30e2f9590196474c9d74d7295e654afb2b29dc6a5b16a0453d8342c3b92d11d665cb52c3078efe561d8b1f94d459007b51708e544ec11f0a7f9e845c105bc2656ffd96244ee8fc335916a1b191fb8518f99aac57770e653e7941fb86919d689a42a956d3000c9929b85e3b28f3fc44de418de74858d3627d22277552bfbd701d6b7e8e62645e4119d2f8737afb91d9887cfe16ff3f56044c2a3f9f29ea5f
+g: ac8eb3f8039a814c713a28a8ff37ba5fb124a849378dfda98d8cf7914f98692c1fb12af205a092a7596ec1b8d7628b58c1453e6e17eb5e55ea8edc5d5bf3f7d9180e8329acba45ba8a1ba4de034523dfbc0bba623f9f8e9a8e057969678c785993d867b0d41b2c9b26c27a60650813bd63ba2ecfd2455754dc794aacfd1358b6627e556e2be0747739c35ea9e5615768e0324b659c7bb3dac376d0bd492d4c11b850dc1fdb568abfce80e8b46662fd17a79f76958766dcf90cbddc984fd46376b0854f2e444baa95e8b3d4f8ea638ad68b3a9fabf203c85fa9ad33b39ac1b14b7a29bcf988975208ccc039d5f6d9794932629629b69ca7f28eb31fa26f21dfad
+h: 200
+m: fa4f65c77419ec1bad74cad3c1a3ef4ef9ae4c8c6cbb826c9ee6eda60fe8c740f8f80f1a88329422b787fa3181be61d5bad5d025d73692baf5721f487b9079a989641372f1abb80ff754744c40f9aebdce4ad9892a1be802f75ff3bd75374a4e20594e5ac63e0eb0eba631c98cebd6474931dd426f636e1d4cf2a625a374f541bfd1efa5b28395a964d3bdf3c4d9a6925071d4d566b94d1e6b88f415e06b304c0b27304f62db7569061e4807
+p: b7bcbbc1f5fb62623dca02d29d7563f8e7222869d65cc3837be8f5a101ccfe8e92bc1483de398b5c43a52ffb33bcde33671f96509f275e62566699d2e2390875f151edcbab34a8839ab4c7b9e2ccade227fe7e16681c2c69fbb9de237222b5c25edce53512cc8690eb88bd16717ce6c09dfc137f959494773b716b929b4304b72c09cb39fef5e9f8da250ec224880355b65affc1972fb95e69421a5515fca5d542e9f6ec337032eb49332c5aa2625f968e5957d69c91250e72c1f52b964066ce6520638cae33efe531214fb7dd0ea0573005879f3b79870807c6042a5b3291a6c810cbdd6baa76639c67923df21ae6794251366f67c17ac6626900748f64ca67
+q: f0808df2f2e74b06955cba686138c4ead7fdbef624f0576da97ee9772dd1ba43
+r: 5bd38c177236c8cf3813f6bf6c5b97db74d8f372c7547c2e27753e5674753ea0
+s: d42f9e5e11a210145e1333379e481b25797d3cb7bf1007ac9b4995360cece830
+x: 356822bd1b5aab798a1f13dfadd408be46a7ed5909be5e8aa67ca0dd0c4884e8
+y: 3a2fa4d36611684a70fc4d0db09f2111793170882e190fb520dc0f3a0b7a2e0b76910a44d358150f57ac9e79e37582bb3d51a556711202bccfb50b9980ba2b848cfdb886c265389bfed32114c41dea3fab42b5577b205cb14d4f169b2d28a1dd6c20bebbf02fd3bfe911c4efb7851529ebdb9e6a27a09c26937d89d4968a63eb3798c1e833ba6485f54d640574db2d7d22da93a2fb4bef1ccec0b6b7c9b0f02e58a27d3f265f3a97a9131cb76ddf53e3d9d065f3ea51f2664ddf05c1c155941bb4e373333d50ffc32374b74a945b0ed4c342c738ea23ca5a4221625ab1eb72930c7f26cb2a04a24f879dd0ded40b27ff0fd50f416f81b0e6d8774c368bb2a991
+g: 61734db989eaba2924c97121d1333bd7be6dd9b2c40772c4b202c869874fd0bd7720ff9cfb70d7701899c8efdf2ea06ad3c05e1f73525c5b6505bf1a251ede6e2f8b5ae38941c622490caad12aaeba139fc9f7b2c204e1540cc379a06921ab9dbc285be694c5b5d4a6de58ce30f0947ed862b3d5caaa5ccc83ceba55665f84a1515886bacd7c3480069fabceee5f0009a6a9f6f3d4f9778f822f3522ba3f1014769649accb61e3c5c03cbe4102a4f20df850e933404c194c9fdd329ce126ebef57c00f5654c301d5bc2222fbafc460a3349c8b7850759d5aec6f79d2545d0e7cf02ce84b0c16a032bebb64d81cbce76350a6a0ce60918e38125609f8c1012d76
+h: 200
+m: 344e88bfe00b72e89ff5c8be3558d3e0c1acdedf3b37d983db00ea59a4ddd28ab1d90e3f49072f9494fe625cf5424254ca5d7f3b6e86579c9f8789d90e6b750fb3bc24642c3d8890c2b8ebd065a5430b414eaa70d599f993c910cdc65377d4b071165d279b6787d7da327bb874861e5c1b00aee6464affee324a98127966f78b581ddc84f448ab80801a0576e192fa7abe1f63db6efe63ed5f3aabba675d5cc325a958b45010845ca008e5ba670cfd0ed8ad1cb0245b69285d83a9ff8bb763d47dae2877b9774c7dbd18f30011004fa2f621c9ad377a94d754dc108ce4264dac
+p: b267238bba20604a2b652e85659e2a31dfa4e2074a6c566efba265eba5b080be1ae83da7b9b4a613e9779e67efb663c5e7b1f08c982031b872113094c06c994637326293911802beec6314ec3516597c2a3f3c8c2519163f4aea095283693bc8792025caa13df1f4be62fae9d9fff2aaf8e5f4fa8eeeda556a1bcde408adc472e6fe684c30b73508b096adf6a22d7524e3de825ba2712267a2bf51cd55b89544bd0f407cc8a2c98a81d5bc7e8a9c880e9eaed204b2d5873cd1e841438324f3730a32e51ad519983c4ec7297f7fa5a184c90e12bdbac4291df584a8704704a18b144f6deff0d023c60a44e9dd519b8446ab02f13751cd3b54b8154f9d513f6b61
+q: 93e686de011b7b330c444bca07e59a1b489cad003447bdc8f0ee2070b0e06417
+r: 5fd929e6aaea0ad965309bd748bb0f29ed73063174e5b56543fe12632062e621
+s: 5951def11ee6bef6f20be51909f21b07c7f8c053859563d605ed4d2b11fd3e2e
+x: 4e088b92640938673fd87c16f62d1e93635abb6b2c3f40c21f24fd40f2b6c7b4
+y: 626aaaf30fa8182c99144cbf8300cb08673dbcbf6b92fdcb8368c64a612731dac87b53c26189d9adc509ab80b358bfd89c69393861b022d04026b97f52cc9c756fcec03dac564e636433b81e04422f5d713a48968079fb511082f8bcd3c3567ad55a1948c3adedaeea06fcc8a22b72c8ef10a70d692620d1c88192c0e3041e96ca91e7777935cb492d10f347114abcc6a204fd250ab20f0d7d014272c29051816ef22d40570c56109042950c198955e432f0153d4791bed13a9ec0fac379642c45ce9d937b78ab7f1daefcbb154796bd1171b5c9a31d18321afaf39e783bd572a3a8d960b4be609a06de126271ff06112912acd1f88373bdb78bf896da74625d
+g: 388f8f779fc84acf4acb5d3d3406319f944baadca5a3c2de4fefc9e1a7b7fa643c628849261a9e405dab8ddcffbc6c93fbe70a9b5495b318e3a5d605629347d8b31688849847e6befebbbf2e79e43ec5a414af5d02f4a95616d05f9896e8d0e3dd90f55773bab4e59bfcb4e5d0f3e276e8e5fe384b6d18652e76022634c77508e43e7956191f4e74fd005930e9a4d909d9aefb25e60ab8120c7ec1707b76afd7b6bc38ae1275c71f00fc099aa2af1f4b6e90bb84fa7d691f3ea74920c5955d36cac9eeb0e8c6a07d9c966beece6bdc8e075334b0c587b3ba2cd030bda697f8f6945700fa4fa4b5258df9e50f4d73d9520654e46d8df6763af645f416ae61f3c2
+h: 200
+m: 5e4b1bc904fe606a35087cd6c79a9ebbdb253591e9c2fe8e899a136f3c57308a877597a0e1c345e592b5c1dab65a2c3000ed79e244192af67556b213f5b648f3e9fcfd53bba3850e0388f62844c19cd8c38466298718e84c0e2ffe08a16af43c0317c1f7eb8da8b1a5945d549be6f95c051a971bcddb49b5be7cb9a2ff3782b77b2a616637f90c29ccafd815429a46ab954cd19f49967abe3978135d700b9ec9e279351e78d740d460e1150d27d791f9b70ede0b340fb90604544df7b1569b1df63cb38d9a764987bc0556a588384c9d08f8db826d
+p: f7d03ece1e31e9b7f6794aeddd406134e6a8bef74966df3f5a53227db6b607df88780953d0560b6b49c56f1efbe24d8192f1692a45fa50990e6367d31e2e65520d70280227eb02b423687f440c50543347b1289da7e424a11ddda443e70386f5065a44ddd485090b05a310476eb5ee839ff1d219fd7c579867875494c3e6e4fcb70f239e2a78426092f9547bfb048f79d95450895291dc73c4242f1f6ea24365ee8212dd4ea4204731f92d7d4f4c4e4c2d9e8f6ae300f37e6a0e192862bbcf57688b4e2417f4a18010d2dd00efe806c5aa123d5a97522feca3dd5c4c5101c006c89af6abace707c0eea0d86578836dc62f3cd1a666d62c47498d3d7d61282eb7
+q: e9e563816813e87a6a244ee7d2974b4fb2f80515cdad284816854bf031f6604d
+r: 5eb47f1f7e446b42b0a5fba98525fed8bcbd7eacffde2abbd786d935762514eb
+s: df66611d2a93db9943f4bd83f23d5a09492bd10c6e008ec70b0267302a3ade4a
+x: ce7e7d8b5557f96e1d1d336d3d33a9153ae44eb788201ffde8c7b545242cb0a7
+y: 1b9542a2b6484c348e1395c1bfd3fa67ca32c1ce4adedb6d0d8e9b53e2279518aee859a2904b8968c70ac54a564ad8f8d55e210e66dc714bf7281e94d6e0bebc3218944457093cfaa3099d62da4d2cc017f1e913e32be85a60adabde406c3cdd6901e36cdff95de87184a76af4866fbfd2209c03440676126a0daf402ee5149edff07d148d30c4c757fe985d2dca66928c2970fbc2d177fd81821942d25485b0571b0c4f118bdbd7176172ae94d94088432a1b72a5780603f3987e1ba27ae8aac725d0d9b5ab3629b79095d4c401a5c7cd1f9d621b739f75a526084d784ed2498a4bc3ac61bfb2c8af428aa1d52016c91ae7233a007d4af927446cb9301fbb95
+g: 19af3cb0ba993ac5f95ca9085690ecc0b133c36615b1ef0d2339b53739d22b4d4e2abf6556f8af9913bfd10b82c1bd0032628ce189795945c23cd3f3b244c77041eb60ff89fad2bb27c12a90a3e623ce547d554d3d3b358437103476924295c1b5dc33d669d16fbd9bf81bf347df9693d0593d1692f16519436e508a70af5175ff56eab93d05a3c50c92ab7a8727b5291815a790071a4fdc18f6bbb1e2759bc3c678175373d6ed7b8c0f2a2e1d5f56da3180a20f01c595766bf0c0b0b03a0503f1526e522c9df5964d435b540d1b241c09f1db57c205ec472edb3bfae8e6316c8d8b2dbd9b010ccce94ef2d00c5dece9d7e6b265f0d8169d0d61c3c9749ca076
+h: 100
+m: 63932df3ffb07f2797ab749e92af7d202b7642c812313acf729ae4b78d556867bca6ac3ee7718224e0dd2ea7ef25758857384fd903da201d6baca09b3207c7c95083db2db68c333249c57d11bea3f1679cd57bda8c1e37868e5552d77aa5305df56ae689a59f9095a894f62e23ee3ada08114f057b0d8bc876b4930cbe00e36787e54d8221f4977746c33b0a7a817f3e9cbff7c1eb456195f5b956eec5256ce3450baed681acddcc52abdaf54999cfeabdcfa6
+p: ee4b77a8c79f3569eaff215714ffccea1554b96501bd33e55582e230850d0f9a66aa390c1ecb32f72b1ecf35497613c6035cf7059a802bb1bc16d0aafc6255fc7c0f11113a7e63d1cd0abb1616fadb48a156e7e8b3dcd3fe95a44c5e81955e2e9f17dd79a81e0d11622e0a4f18d8465c6d839acf443681d00b30d6ddb927fba5d922598aef47d1d87efe92b2f26fa6082f16f96392581b7857e5871e724c71ca6c36c967b2bb43aea87e739d15eb3c32b5e5ee61e36d3390e1259f7ad212ad9a3a22e54e3842ab5a28c650d704aff148cdd3e30c7964fe90e293f8c725589ecd75691f2e28c355c1e31b04320b4e0a79c2b4aa38463ff2562dec88b9aff35983
+q: d2b63e06f16125d7ec32cf1a1aaf9071ce69310e5283e7bfa0888d756142b5eb
+r: 59c7fddd72639d9a87ad8396bce88465344493b118f6b7e86afa31b2f192f173
+s: a883a83e5a2a692b9973c8a24a3188ce12db4e3fbe08c25ebce350ed07f5e3e9
+x: 946761321eda5234af454d161cfb9ba8527856fb853e6554e661f24141fe13eb
+y: b23069fdb957d8b81b046ac261cac01546d42ef4e68abfbc7a4c144c9d449ae3ea00b4c13b078c800da7190ba610f4e362a2b239146f7503a03880f22ed3dc15cc6e01e384b875df6cbea8ada7f2e67be7c72c83dd7748a858e6603f28b9759786fbff43c722a6d57a839fd45a3c89960d464c2a962fdf4fc23307bd6ae32faa223267113a9bbbe74b5826bb9c7baf83ab0d2893c9ffceb904e7f2c23163a70cbc026da20eac66cb3a5cd0bc2df17e67add12a6b1820bd12e3957c5c924abf5a4112e8463d326f62ccb5c402c2cb53d90b3e717baa14380d136ca1a2ec7d419bbf30cf8f31f0e702b5f2b47d73d9682b196ce087ec754973924e01b389272ffa
+g: 7c6c72f8dc74ebc46ac0b8e672c5c6e233989fa88f7a59872dcb848b2e7a0f514da136a51b74c2493d576d3c5f7c2f975a7f680767077810cbe722c37524ed21d39b2cf70e7e484ba7d9d3ceecaa5dac783e56be81bf4f76e09929d011581fd53a0a9b73dfafed3e8436187ca2203044f167cc319773ec5850e9e13dfa13ee5a95eb0be1639c71e851c4a74224be7072358c016841f96b58cb0ea2234424d4a7bca5b8603ac8834a6d166976fdaec86f97b174b5491fac3272dc167713996f74c9ed2b1b27ebf5596f2a422bc2763987b17498ce9c3d8bf9fec77b1485579809197f381ff8994a9e4e1ca9c8b958c1ade7838d5cf9ee45bc1f6774a64ae34b29
+h: 100
+m: 37f9dde44693ef29e7717fb2ff00e9103d1468213309c651544e4f9fb4fa2f94997a7a1bb75c4c372727fc457a0dd7929c2fdb263a6800e14cdf1ae1d7ffac1d773e30d878eff7f8e0d4037e3a6752ba8169bd089d2196e81526b0952ef7e298b12c43ed5a81b437b4a8e6dffb193faba8e5bd8da3f25cad4cd3577bb4ef37bc65ed64ad8cab3d9f79795c30ee969c5297ba5599d8f016d89201e2875d4b3ff885e6a8ae23cee0ec7d67b26e02652c5fa6f576381bf2874be55e7fc273f62705a0db56ab6452f9ea5143de85db10aec6ccc3
+p: 9bb0886277e09edd5c1c1f54757a2f8940b6a539af0110f34d1c6cefa4ee8d21d0d58be5f235a3d171b68d1f01e4cdad81377db81dce2208dcff101160690ac18cda27c0b5af44aefd39e43ca92484b950ff0a5cba5db13827f9bbc4313a36b4950bfad768a10e0ed71252f5794d7baeeeb5f2a089759e62ac03fbed5f8ba58244aa517c9b9fe29fdfe7454e5259149a1654fdeef81138b4a5c7de650b7b74f4894412ec22b7b66eda9f877285932b208f7f362e18ed3fe78aa193afca16146aaddee1c2884891276b222c8cfdedbeeaff5409a34781f16eb2a83622fac07e767699b4b28ca6b0fa7f4ba12e8d32a3b1ed02e330ceeaea9108a59ed9aded5dcf
+q: e7e0ae9c0978ee712309f37a28e8de237552d96fdddc3e83cc544403c8a59ad3
+r: c62dbaad84de8ed15b28ca9c438ea7d1400009adb4ef982c29058ce9e84a9178
+s: d737dee6e9b43b86b3b15d7329adb1a87417ddd2e62c0d2ea6c5410e1c0c0a5e
+x: 4b7fc55176b49588be2fb62c85a36f6bbafc75d5b7b8d4089504e73287d394f7
+y: 3b3c00e3ad57e45bb5385832f585363573f4cc1720cb5857e84a6e49c02eef3c70cf5b2f52e88db401913d5d4a4fa251f0a572d967fd2562b92dca8ad2a4f066d94bdeeeb9f2b8b1886b9c2ab46fce7d4c16001017febe10db1d0e1b7d03af8901dff5248cdf2704e9f5ea032dd12ca7a9e1af780eb8b47109bf7fb3fad706d4ad3b557652fc5901ae3af9858bced373d06c9ddafc8a9a018c88fa619b8e8920deb3e0a002c91037dd59cbe55a08d2e04a56ddb9a17d6ffb79dc10434d74a19816aea736e0ceb5e8eb1b03eaeef275ef96f639b84e0592c6ee450b104bb1703814bbec2b3cb1782cf08da2b8764a5ef1709edebf61eefe7765ddcb449c9cedfa
+g: 8026ab6e5b7629490d7440a768c61a71fdcbf71a9d0f14246eb5038607a41eea962e55688398f4f6b677c66c094c33008ce8ce5f94a6fbb5dbd976d735077f759ee2770db6c423eb14dc53389782d2d1e5f38a9b525f4e266dcee4e3678df6fec436a92cc8a1a6ab86015acf42b7bcefeb95788a862f940022c205e9cc18cb2a9edb5b769eef3a4a23ab1735bf031a430c6e58b7908c96ad658b2936cdd4f7da23d2280bed47a7932085ea9f7e128e7abc6f43dca4f557bcc713d8a611db44f5ae96f496566da6badb53e0346335cbef34161a56c676a751d70378082833fe30c3a417f2c4f524fb40cead58346dc9eef4184a0ec69ed973be3b4fba33d2de30
+h: 180
+m: 99d6889a5570193b30ed19
+p: cf173fc725a4ebd1885bccb5966ce3f5d537d76a1dea2e38732e3904f2607eef3eaf6cedd8473bfda382e0ba116515ddca45115bb8ef474199221adea40d93995bbed31ce144169d96066a01557a50f9261bd1bc492ec321bd13f0c690fa42ff408e1c7a155b202e4083d315c2330ca7570f0f51abb5dfc97e163c41ebfe0649deb0f29c9fa86dea061b4135d8c2feba16766cbc0d7a319e600c90cf851fb3e0c034317f44c53e94bf12f7d814536203000bd3b114a5797335b34408ac2f2b707063c5526045cb6426c4aa17a71dca3c1e722743551104908b8aeb84a6901c0c7f2407e93e790ad246a4dcb1f575f04726179ed49816fbda08db5f62e7f72f3b
+q: efb1431558205946d5daafc2ffc70f68d36eee61ffe7bc29ab892844847f6fb3
+r: ddce65c1cf83aa2d98e5dc57a6ca2d9da23be063cf1ed5874080d25ca46693f2
+s: 66d87a54d9733708d3911099b820184fe1cdb1dc990740b2a8088254603ba6e2
+x: d7d22e0576fc1db22da198e737eab989e0beae24661e0a07de0b3679b85aa8cb
+y: 95a70c1bd373764a6644064946c18b04a4f1df99ab7805c8801db6ec6b58cb752f7e231c91d2a2183d49b7311669931d1a25ccb2199e0cd6ef934ed2580d5a2afc3dc8137abe0d18e4aabb3115a2b16a6905d27ca8644044a590c2d62cab3f7e88009c03b529d1bcd1ca5ba022deb9044adbf54984d2e4837da5aee8ae90856f3304b5a9f0a15c4222bb4254e0cd604b78805596b64b76486d7381a830c799b0719835ef9770ae9423821b2229ef51c38b208f8af6565719a26c3b1eebf6966f89b34eefaf4952a2c55f50f55302d7fc2f1971746edefc595c9ae00c6fcde57102efdd152d738becee526fd79abb128698033e4bcde6c09b1114ae23624a0116
+g: b4e1d2028a6f389133d85e3b061f14e66b773dabe95c74479a6374bc669147f5518d9975eb153ba174f02c6607ad61a0527e77561e16b5502a23c328435d7f559dc22727f2eb7d9a1b094f5e72ed605d7430c9cc9be739c6ddea36d08846909d233a515781c13527e82c4a19b797a521f37f4b75ebe96ca7795ded21bcb3dc9dce2713b2c37eecfb9deb729243ded4f84462605446ed61fa906213dc35638b9a184055d31af876fee604463daaaf1b1aa9c0cde425a7cf7c5a6b0b4b70852e65df0b3d4021478b8a482f0dad940d666056237edee2e3ae23579c8b9cd05ac88b0db66190c3d296b257fc7cdb2f949ece9a4b28b96b0836e11649d67d94bdd403
+h: e0
+m: 1d212c77a95d98d6d8f9da18f426989401ceb5646856636643041e925339feecdc3ada9eb0afc5e8c6e87a6017ad1c984f13f9330520aa67c482dc5c25d4b8992cdbf95e08ea84f9ab1dd5fb688784b8cfac54e9face7569a8e93a5f19ca47d600e28224f017b28feb02595f06f303e877995415c15ad0d058d203e78c1714e302a2046160533a4307dc853e1d452058bbac2eabd15b695b480ae9e05a107d859e1ed1a787005edafc10f6cb8997dca91708473e66d8ff03f0fe543d0e7b
+p: d42a6c750e0b41e0b6ace406f39d148adc383181e63bcb5106d9ad8a41ab5f7611e53de1fcc52e17b453c5bde071970e91bf504ef50d82ac24a7aa682f9a289f36fbaebbc4ff50a29a207b8c1769103345ef16f3dd51367e92aed23d4be71df5e69af483c72857b669d672c60b4367b10176fbca88deba8e8eee938b8ddcc7cb820a8cffb307ab9950458a871e91a5a112aed22bb180319e4869ef03737a9b9210d84b52aeb6f4f529c9c2eb8330033cbca7fbd122a98bc8fe511ffecc241c74c6fa2b0bd6aa7b143467edc383816a5ebee7e0c505a43c5463512f6026bdb4297ebd5540220bb783deeeac8548389c4f538a3a4ef34e6a308cb0f18b0f48207d
+q: b2792bd300158895a0d0c4d0f88df3fe04a0c021cd1b705cd7e80190f6765e1f
+r: 84b5f531f684862c14ddb6d51008992177fc57dae0d5b3673f6dd841638062f6
+s: 35646f89d60b6bad191b7c01e84cfc3d16d9ffd39f4674a9a47ea08a8ba79d3b
+x: 4e8e4f2681613b1941d3278323694d0167fe1e19c050b0089e505502fcc81acc
+y: d13ddfbbde5b088bbb6e57c845812e310e7ec24cb5ebc4608071ff0e14e115ee5869eec0d4a066f09a80fd6eba955dbb845b28250bf021f6d397f22b33b82131e92a9b8c012ba8ff0aa0ad1d515748622bc7d1eb2458d63c39b885f460805bc3f44ab9d8d228c1da45e645eb253afc472122ea4660180d7d710a397fcf0be898f043cdc2d94191193799bd10b4dc5fb53e551574202149a8e9351d7a8fc2b235752533ce2c2fcfb83a1352be8291b8d82081227b96f9555f9565ff9da968076eca545d1bed3a76770ae729e881e17aefcd00a737176a49fa7e7dc806df1d1e7d1df77af6c9f2dabd2786915d93e0a6a8de9ba62ac331f6ebf1b6ea34f08df7d
+g: cca5d135ec9d2bf01158cda42b6b1ddbb37dc317185ec54bd90890b58907039018ab65cf0b5f29599c6eb19a7aadc4268e94ea9f410f7d75b6c68cecdd303d4d4c6766693494d82e73fa58cb7543f865cb510133a370c4df2d269155323f5be3c6f2b19fe58bab0118c3ab99d3bd028d495aab29a9cc3bbc2b1889f5320bd4bb8a671301c98b2840c6e8478819afd5bf49543adea2d0bff84fd4e34cad9b8248d15ab4b28eae6f26e6f403c93c6f9da83fa142d41bc48896ed0cbe456a5d0ce690e3a383d67a73a38c3a59c065516f665137682d83932d463bf916a691cb3b45bf94f8bfcefd55fbc841ce3519803e6eaae82a3ebd770fffe96e12c58e37209e
+h: 180
+m: 1ad404625afba54046bf87e04c6e5edc7e4c53b42636596d01036897db078b24655d8e623441649bf70f21711b0bd14cfe35257e091e98fb01f8fe5f8d570378b895a996f88768a85831b2ad7e25e415faced740b69af0d64bafd115265a2540fb2654152dbe2c92aaebc948ed0656bf639d6a1cc1eb16efc1f9444b84fea8fe173f36b3
+p: ece373c7afa118bf4071cac52f31570f9bb55457346e18fb9f0ed16506cc9d8eaabeb4fa62f584efced2cdb7d3f7f4e881f092d27d5fce09ecabf637b553988e7085c958cfe9fa24db5ec968a007e7555102bbba1085b6d910755e8c2ebfbb3889ef522e9ed13dc49136685774887c46cec3e6bd07a863c73ce0f0e6760cd02d73b73c4151c459465cdc64f4f535ac59ad2dbc5c68edda1e9419f11f4f4404624ab068673004739046c16e38b0e02ee80a57e5938f82bcfd844063d94300cca7affeed923f70a8ab7265c2166e5c0d76c0a1d929b590c0fb57d5983574d4a7c225dc5e0b698087a5090772163c2fe88a3210e13b95fb87d8cf8f45a9c8a1933b
+q: fff877e432fcc89d58674e5ebb237acd268ab2a70adb731dacab12618cb20849
+r: 9516009e31dae37fe78bd1fb03beff9c753f24f2520fbf07e13bda1649832afb
+s: 971fd8a2e073eef11b4a55406f25d30c3501d4fb32531fd49ee017ba9688bea6
+x: 8283f67a97d557a8a69eef0688560dc323fb7f6b11f44605604509a978b36d5f
+y: c54e6f5017c72c8944bc6c9ba0573046d0aec2dedfbd03bd384a44234fe221877c0d03d6822b04f2c1b6855c138788d0de1da66df3fac91aca328c0e33ea51c595e518169e51783657cbd2981c8ce805b35bcf8af66a30533e0778b43011eb41c2aac42272c2868c55aa9685d610e59a76ad76957fafc7f167bd74494ea5d1ecc10e59aa244025fa364ec4ad213beab9607b308a0b6d8c33175825255ada2188777a692f5466f5559779ab0d1ffe5e5156b2eca8729141e223dfd81d32932c71bebd2b9c226dcfcd7f5ea6b70ccc288d11e9d23e0cb0a6390e74ace293ee172c537b552dcee3f500e2d92e7acbb3af6dc2a2294eab9b034638fb2fef7f51d80a
+g: 56dc5c1ef24d9f2f8c73f3f8a7907ea962bf51fb4b0133dfc3c2fad7a4fc50c6dfe6906081b0f5509de0bb678420a8efc232edf92acacd2fb48eb806c86e384ae1fac2ec6b3338f7e7660805008b2e44d13777081f7b2c78674877cb0a891abb32ce86841be35e3fd3fb7aebc362dc1d47714a53c82fd7329216b83321bb968bc8f6d817e4fe71ceceb14cda332668610f66bc8f32088179af6dfd83e33554b58c40dacb725c23a968ab553068829c82c7484d6e34e3b6b5731fb7967fa0703dc532613efeadb4a9dea8d964955db299019e121b9391e846b576c713c89df5f0db930056affffc8ac224f7453d2c8b7647d6b1e7a7535c9df9b43a7e9d03ef36
+h: 200
+m: 9026ed558df31b65d3d8153b201bbcc887043d024ce6b2a30efcb9b1a694dd95383dcbdec6b1758a4665227346398cde3c2ae4cbc1de959bc42e757bd6e7ec6fd24e1e6a55e0df0224a627f6cf3d65fb904c7d515d707cc61953bc0b79aca78697bcbe952df768d2a3cbc037174e2b4b6c76ab842f826e2c35d68d07b91633617fd9c08e3386c23837ad7f8454f549b33e26f8989c42b4ef075b8598240f6e87d66b27078d6f31ec460ae6ff0ece7daba4e5ef
+p: c352dfa974913a5d47cbbb09c839782e582a820662f3fa5ca4e5b69446c7a281bdf713ef9b4cdd1654ababde8648874bbc17d59cca8b21abf8526a829db7ea3ab4463fdac6dfc1ce58441529f20603489401b34e097738e33b792df1c0f2a8ce761814cdfa660e002e100340c512d7404bc8002ec1d5c14728a4a7caf5319df81ed5b8638f4f9bc3b1d17cc25201cf9d8038c994403d84cb482f58dc2211bf6fb876ea81a69b18302ffa432073b1a1093ce726b106cc93cbe3bb242bd32442723c497345f230948c6741a53d9d1cb5b98d80889337e5ea7ff749d1b951672601a04b52920e20ad93647e9345c7093687be7b71dcbce6165ddfc5ba589c0eea87
+q: ba7dcb38564e75531d36d642b4d4693721c6a2a6997cf8542dcf206307581d87
+r: b9b86c666042877360deb2d39d7fb9c66eda12ee241254353d21e6e0d6833a6a
+s: 9b25124b4663190382da29fce5b9e4d43d302cfdd39b0b25be0e99c744027569
+x: 9ae7729c62d274c335c00723dac4f60a6c063cd4837a0cb59fd8e08b03e6766b
+y: 3e2fc195332100667b7ce4662e63f18129ced06dcaa5f3d06107514dfaff4b880b97a1f8162cf8d9e0e68960928c66d5ff00ae4fadc57a9731ce40deea0061b2d7d7218f2b4b82ede58ecf0f019f03ff20f00ce4db4389e475e29944b4cf09c85f36f1c8f352a10a9fb5cce9c00c98e57dcf8a5e092731888949a67e7d072347969afc54232ed8dbc3d861250b9f57789dfd3e3f2472c82d0edca2e7dbd22804cd7a13e81fd0463c12d89e389a522bb8bb6147888e2bf8b0409413ca9a55318f35c72a0f3f552b6ac6d48012475ef5a8e2c7d973b002abe5678b327f3e3daa206c33251b5e94cb0efc7666688801caf3e37b2bf0754cae1744d3102ae827f690
+g: 3bb3d187dea54a6877d3e8b1a2eca5d2f7db982c105956b17e7a975f1c26cb58dd341c5023fcf9a72aeb4fb36b6f51e42cace96203a0bec2d1e368973101ab5c9b2c5c0ce56e6572641ae65450ee13d31273636d3a86c2d19074fac4782a80c5fd61d98184e4029209b4dff231dd21f2f6a6908b8941671cbf2a8be2c095531dad69710130ba72e300a5b379eb1b95215ef60109faaa246effd15d5d67bf7cc745189bc3cd6041e4b4ac5a5860b2f1789d6cc4e801b45ef5eb0bc82d6c9d7af97442f5cfdb9d14c6ec6a292c00684c78103c899612b02ab80e88d0512129b496301b1876a83fc684318cb780f1d1e385578d26510bcde49bc792a20b3ae5e7bc
+h: 100
+m: 890337b86fc7bdd10bce5cc562806b3c7bd9bc5f65657ff6d1e9caaf4a0517610f247f0707e18ffa3663e040c51ead6d4f7aec91ed8e8d808fc7ed635cfefeb260b01a940198b30f7c0602c932a57aa685e1f433d9692b4fe67b48d53c5ca67b0f235a1f0ae852c6f2f69c0fa64e3fcc5078003093a257dbcec25ccf8ee3dcd199d684f64de36bf17e7b36ee1db3b32a3cc153debf64ee5d52f8fefb
+p: ddfd9565909d4a247a9bbf9a8f333c5eb5ea938cd507df896df79066fad8d199f6cba7527ac451ab852291e0a1d328766450fb9452a76542206a59dbb71a15bbd6caef6c68f6edef11d6b1999eadf7df5767d0b3a7d2a3d1e017bc4548d6403481e1979f60b1879240bb380cc2efcd405d4e4e9f7c6d2fe028df2f3cd55133ffe933b7aec7a1fa533f0d5348dfa65c1a6f6be64f41248e584aee93e813173b8378514b329c1184190bf2f34107a8f708f1467c6342470859367fe04be78bddfc4e119be10abf9bbe75ca2cb705ac1737a34a33bbcb1570e21a051e2d9f0eb427065ec757417e0ef894d1aa35e68b922311b39056d1e330d202607fd2a72bb433
+q: 80083948949d6bc5f35aa19502e71f5da137102f9754b78fb235d10a6b0ab019
+r: 67bd109f6d08acd46d9b62b4c9b0e47c0c53a7af8b12c82a88de323483710fba
+s: a28faf9a28d27a393b4982722f87fa0ad9f03122498b60834573a3eec7e8f5
+x: 759cb4b9c45b6705c0d0f044ce89d5f0a8ba95a54a97af53db2be52b496f6f5d
+y: d088607f3accec36266202ced300e035549b46670fb1b704f379c636ff42e2d650f656be28c24d021f3f852fcc34d21d2979e6900ef96151ca554de550dd2fbf0d2ee555f6daf0eec67894d9899a5cde1d1394db4db4532a12935c81d1f6603286362e632063ceb86a886037e5c0e3a6e226f709baf4a2733e6477c79cf881837710ca93b07eec3eeff60ea96dd0dd57d6fe187688ff5ea3939c1233798a73994ced4b3edaafc4d29dfd801ce08ab626100bb8344d265e01319db4b29bd7abd541c0b634a6bc397c5bc460b4433280e3384d30d3d7cd4c2826ef48cebcca1280ebd50fc315aca00e6269b5458694fa8bf24b971727aa6d8b1b12b8a70fe3e549
+g: 6ca2f175cd3b2b52bd2fd40f6faa36da603fca0345dc2c5ccb50e64e9c028b1726ef42196c5b2dd9ed9f5db4a3a987f62cea9e554427c4cc4280abbeca31afb684de63d132a9411d786614dc5faefd6d309a54da7f3396e352e1991fbb34b4f6356d38c43e6851bd3a97c44547e469585fc77ecb397fdb96a738a906193e05f70b4e96ca88e02d7ae619e732fa204889d3a111cd1ecf93b8bd215917bbc06e39321e730c4450b896f638c616cddf7e611bc79dbea607907b7ec2338a4fdbc39a5bf6f6ed41f8e062606df2d271960f28e482c0c02abf5b5e3965286a09331fb15b16e3c4e67fbb8067b867eb054d2474704c4e4ef471b7ff86e6e7fd7a7b98e4
+h: 200
+m: 6bef6712488c2bdd20324bdf5bcaa1c8c97f82c94ea3406e5bc0bea6b3d6d7c2ef984d4c8dfe6f077cbbce5f0e68486d4bfd1af62b8b05597e0acb3eb8385309287ca6
+p: e8634f9616c0fb4354fd4c2dcaf438dbba1ed301dbb71ed1909b9f4844f3d18a7d02ef5ab9a907162678bf170d875140ce1962300c7175acf5f7d61efcbab980d0a509ed48c31180b36e38755c4bff35395180ea3090d6cf4c6f04746cb0494959e97cdb598b393180c1381b181b9d3918917f565a387949eeb0d87385d0a2397394574ebbd49c6cb100c7f29adec9ba8c71f9a8023b29b6fcf00f735ea6980f71f26692ff142fe4d895330611e20539783ecad67466a2c7e944e928d27c94eb183a1af17a0f221eac4de11ab5733bf23c5f3ef6f02d123185744facdb7e532187f60d1d89de294161f32b78b1594ae969722f0cc3b3038be9f80330e971f8eb
+q: a8c8e31a4a95eae37996fb6f79de03ceea220724cf9a701663da1af728acb1f1
+r: 796e71a88caf22eec9f81b2c0428fe6686153b32f14d20746cb7709a4ce19d5d
+s: 308a2967f89a0319811ab4f1143caf651f2e409af7881bdd4bf43207be364168
+x: 8186550249e5c62be784bd81cf70fc19e64e10e664d4650f6a4a34de7ecf038a
+y: 82f8ff1b3a9ed7548adf3cd4402ccfbe6b4f32a1419ee74e8fc12486616a582c7863ed1678d6bb3bffdbbcdd883d2be2db89b337b54cd9ffa8b5a52025085faad16711be64fe99dd0c1a0ea17a22a9468e23af9e4b6d3fbfdb2b67e98abd912c956d7cbce7064b38d188492391a06b75d2c5f3c19fbf8252c7308c326c6bc63e78c6d5620a43649b60884b041ada3b5cf2b23a46a5ed7c7941dff60fc08a6a727bf7893b57ae0279cc11f876888d0b5dab932fb568c3ebf59d491f04e9ea3487832a29ee8461e1b36b51b3af763432f86f14f0b7cc69b755af9ea0cc9f81fce564a50b8842e1eff67174cad37e139b61edcd21f5bc7b929a3f05ccc06222f0c6
+g: 20c7079f6d3348391b29461b6a89d16c0610485a66342408f6fecbe5fbbaa5608fa538026825726fa3b6d0be00dda8b5911f5c5fdbe7789bdedf39dec2aab45c52656fd62b7f4194b8aac0382a6782bb1431b55ec9ef797f96937d99561ef488640b1d7bfe1844105d7f7508b07952df6e8e0a1cbae97437dec4b838f5207a71135955afb862d1186a2b211bfc5e9585de84d64502b3e2075be1cc67ba61695b53522b3052e6f46e09940cec6dec4c147b417f594b2370caed7a1c2d8e34d1bbc02a0d82d10750c088c37d2467d56bc7c60eb2528594d556fe1ba7c5c3b868b14421b9755d05e7b5679b444c00b8db5f9c7188a2770ac04ec7627d5808961cdd
+h: 100
+m: 2899113a51c5c68765ededd2921ebcadbe27d683c65c6917bd411c3f93a243df0d09c21400a98d8637e185f6a4a06d5d1c6a18c0258b6cabdfbcd39471cfb0bc231f5973ad5eb4547177aa0cbdfa62d1b3
+p: 9bbbbda9d29afc32dbdcbc1284a46ca2eda6ba2654337a41842ac0f65fa4896eb9d60ea35776ccf881035c2f6afba24ff46ea3e156cf24c21568416bfd1a2e2f6c6ffa1ca30472308fd33c056a016129e32209bdb0346ef0e1717741bebea31cdd24de90c18ee55c998cbe9fa4f9a8a98673edb6f57f8b4f7e277558e2d3bdd4e452d2c3509afda59cd5aface7a5e056a26213b5e725fb55e2a32f1513c926919c2412bff3b828170e0004d1dd430f677f3a1b954ccc6b30bafab98dd31d2d947acedb59900a5305463878ebca0ca3e62bb91c95b0bda6b51de80257b899491e7827f6805bd7d55809b9d0b241d8523bbd5a9831095afb0a6d3bab1d32206c0b
+q: f6b7790c8e3c2804ae76907e7fa14dabb566ce5bda517c7504ccbfcaa740ad2f
+r: 15415226a30af81c068778a39f9dd162e3d30e310b4e7eaeef6e3b98bf15c8b2
+s: a158c8f1e5779187dc12ef94d7451d35cc9e3ac2a1c21edc09b1d738c153a898
+x: 1a9cf01ed5e9eb3e01017561078dce7790e21e4ed9c39d3aaf3b43243fe57af
+y: 4406d1f9940d80045d44397582a7a63d0e6efdcc844798f20e1fcc0c2c777d0a468a5f1a06b6fbd7cabf6a8ee20ffe93b3618f4ebf910341812697ce7dccbb92fc515001296140af195837d2fdc40404884bf654d108b5c2af333d472207882c328196a672604228023217b2f2b2067a4aaf066cc53d67c827131e9181f1478cd1badb3e4bd3036c001b5435a7051bf72ece6e3eae0e32228f453a9fa4485e6f5f47a349f08f0c65f24c31f0a434444660526f37d8cdc1337f9ec357b5a44c6a86c9f32b5869e832ab4b664bb482f16df354803ecdc094eb2b9c9d65cc305205d133d7724f1cdf02d2108c020c97b5805096c06e322fe9bca0661d683b1458f8
+g: 6e6c230ee7a130a1c099969cbd22ecf583e9eab22eb00fcb0d43c513d4f0771d09b1d545aebdeb86718d1d60059197785c716abca74055d6719a84c03a0fd680affcbd74f5bfd11cf0adf4df98224c804b4002dc0c657d2e42f1ffb87a0245b33e4ae56dd975e165647e46f8d34fcfa3004a6e23f6239a2a5fb00a39d752d94b7dc31967f1fda48a8815057d5794bb1d682c9c64a9b63578090c0a1abc265b85391ceb1b82b49fb22abffae4ce4d8d0806eb5c9ae331f1666ae542ae68a4528abf1852d027131a1e17703c10a5f3bff4694e99f4de5defe110de314af739eb49f0162e0da00bce8a02e8dddb8b8e2c962d32523983672ef075104dddc9e4c6ae
+h: 100
+m: a343c7c0a91c44aca6b88eab1e3302dbd84adf4ebd20f6ebab85c3bbdd
+p: e3908280488206662f49479c7aca2ea085863d80660d87bdc69ab54e40184b747e472a8c824615d66403149674860365556bb606071f67adcb9186e158154ea5f8e5909630788d9f54b6021018c105e2edbf3e6156fa30d753e4d7822088ef6eb431c5a0e603deb5f37d4ae2ee72794de594eb3d45eb84130616db3457a805abf6f80c7f34d4abbe39d257682f0251a6912b939a2ce45d1db664a85d5980aef20d97eb4ef5fb5acefaae4e3de900f2bb70d02cfec0d35ef71cc7982358e5244b16b5ea40e284feb422abb87dec47e2846c040ad4b016c47b5798408fe3986ccda2fae467ea84f0e0a8099e45b45c3c6a0daa36e56899821dd497f828736f63d9
+q: f233c2395163266622e121b83ec29dc79ef7f83ce258fa4ce81cf82042127661
+r: 3408db8c3e2dec012ca9ac5de29099f06f9c6530716fc796b4e192f7d4013d3d
+s: c23a95ad647c780e0be2fbdfe2d42bc57da07b9918700d85cf9e49beeefa3ad7
+x: 74a2d6fea2d8f041c10c3737d9747104f5c41f58f89e59d13edaf8591ebe6dac
+y: ca3681ef51a692b55e70960ed80b605539a5d9bb625d44f7c9125aec664a88fd37d004575df98e4b0b52ce76116abd93bd64ccfede42113ea7e98bcb17281e14299d703eb8e484040657bdd539acbe4e7731630e2dea3ae3208fac92f180061f0f883493a3c7a37972054d6d4ae646afd60ffd76ac976a404c6758c0baa971356edde9c596d9db04109a2ae1844b33c340560dc75a2511bbb985539839335a57873efd29e30b95b1c17fceede808fd3d412339b1e91b954d0b3fd714dc51cab5270f1bb4e5a296d1bdbddee35cd486191b586ecf0b754f353744977dd9a03b7be100e44b7b7857fe80eabefdfbc4b86582cd912a5ac6330bd35b6f69c21f4a30
+g: 3d7be4994c9b044b7de4f66ae796045213ba2df278fa55d4e357acb22f7a38874fbaead347b1a4e5928b6f1f0ca52981276f46406e7333d4830df201a74fd9988473a4b849df3b43a0f4ef03dafae34df95b0d7a22e445283a151785132dec8b30b2e64026704115be684d41b611bc874bd488fbd05f2f4bf983bdb997cd8485db147b1b5b93b25650feaa438248d123fc60f952a687cffd1c7679ad7339943bca6f782eb6f53a4fed98f0f3c7ef1f278d8b82af00e3844905d8dd0ece918aecae0b5e871be4fb6842877116112232a66a0da9920b6de753fbf28008aa9b8964b80464908be860c826d8f767711a70227645bf8329b053a6419433a77c29c11b
+h: e0
+m: 2e05c0d36fe4c1197df12e6e78764fc4d523064b007578bb0fdb710fb9880a4d34485889f5a938660ae13882f297ec59f8b2be68986b612c2d30f92ccd53b655aa12e830d064a46f6f1b00a6bd6072d03e16d227bbf7588e36f8f849eb3948c9336974ba3fbd99e7c919d8bb37fec8efd79c9d80c087fb1acb416d81732b30b32e141a5b52ccbac2843cd732409f3e729efc86a0a6c14d3e0412c558cc76963d1244d3819f6193d491e75eb7
+p: dd4fdba7f8222d5f5c52b127a2f51bd70c45b4e5ced6cf47e2ecfc02cd09f2bba372486d1e301a4662601d27e1586f29d8241c5db63ec1eb69e78ef4b4ed36ac6823077fe0b03ce0b6c6ac5de859f8ce636e140588a5b672a8915e556d030e72463ede70f6a3940b2218d7b0d943490ff6bbc9a8f4f56f959efb11f0ece0f764403b95d97893ea6795f0d99a10291f5123837f227625a0275502599d895e18c98b6b2dac0cfdbe22291821f554b9874a85ea45dcbd601adafb3afbf74c47e075aad09c14567f51afa07bae5db340f1f7d37b89a68d566500ffdeeeb216ab0d8762412e6e73347c3d13b744676965d872749ad909577e6386abc06ee097251c61
+q: cfeac6e0b5289d2696b763391afad0cddd6ac18df4bc15b2d1bb3c50af16a9af
+r: 7529308e2753398381eb89214c4ebb45fa6c15141d5d427dfa4eb8f63d2fda67
+s: c775c99af7c0217ffde06b5bbb2d2fea9a4743b636f72419c1c423f15f21df96
+x: c6cdedbd3d6fb9e961ac2196de846a9aa619ca2eb69273ca7939466ff0bb1790
+y: 4f6819faac96f054bdbcf6c9b042cfc87a1afdf1100a841c10e5607c90cf14fa172ca007f1df7342049ee27beec27bb80382902080bac15862ffe517e3e08f121d9c0e4366703d4be8822f9052331bddd265a4c45533982e45caff3a77b4aaa339f400648cbf5aabd46f9bc20f0c96d5f74ace61834da4fcda5ce3966324017a1064e6007726fdff6edfafd3e45c252b6852176e83252d89c8ef381fc1842d22884a52dec1a13029f9ed903c293fab5510a949acb39b51a5b80cdd45300000071936fb5c4988a6b9660314512e5aa96aea31699ad38a2a16a861c17ede3ac55edff5ae2c7a03005eab30340ed8d1a731005c268d74841c2d479eced6f17e5a15
+g: 7c319f8ebfcead26f4731249bb341713d9ee052cdea7d3fc778b6775c529fbe3fc88ce0100fb5f1ac2e276f6042a0c316074888de69c0268d6f58567ca648b74e7bef708e526feaad05ab1cdf8a51570faf2acfd8a6b9b600002c586d906c353b609e2d71e0d2c99c35644f353292f0112e2fa70477a70a01a29ea04538426389bc70921f752a728f8ca3b26ff7f6b71f0473de8f0b235bf2b25ad795ebae5506a4ba9b954a507a9540d7b9df31bfba004f19884693cda6323daaf8f067e8f4bd119e63e84f61a6bc10842dbac9cbb8f947801b18d0c182ac59bf39f9cc1525f4a4a0479eb00a78686fd4f0865e130fb71dd8b28e2921ff79517a85902f3872d
+h: 100
+m: 392514fc513d86ce4bd78e8b1e02239bc7534632340c0275feeb302e889951687c530fbfaed16c0895656ae1e89d60c8c94d9a1d3f29fc1196d232202390c7d4853720716fc41f24db90d9a7d65b4680a1f99b475238c4163e4f1089aa534ed781f857f001ae84483611c5ad7768212d1d99082c3623acbb76aa14e5e76e0af14ecbd405619a561d6721c0a4d15ca1fcbd8d1a08386e5f50b41f4a581e0084b3b3f01e86
+p: 96c488686f2d4bfb2ef950454506abab4af52fbcabebe24932f84464468cda68888357cd7729e4de1cbebaafadd44ce7031a4083140aa612b2c98f54925a8ae0f7810c775fe2793bd765072aaebab567a5df5f67e61d89c2c0903576c004f63f4d0839fb0eed60fcadea7cbb3fea4a1620d37fee91978da273c95c1751db58abc9b1c45dd35d42f06ae80f86de5a440dc3087bad45f4c20f43a042b6aeaabb59b9a1bcb71c4a12d1362f08068244837e55598e441210683b006bc442c07c3de55effb52679a1dbf43207dd0c8239044ff12927ba396f1faa04496801f1771dd847822a6b43ac5233051f24e7eab91a0c187dc9e9801c3d1278daac1af0d14201
+q: dd7f66db32859ed42f75fe6ac4018d576ecbaadb167b7af4b54e183d9d5f5865
+r: 40bacc07a1955eb9662072ae51e59651d51b9830246271a3493060c216134d85
+s: 62321dd2cc990b7c988547e0b7424a21e9ee8fdf4b195934bceb683a39cf5446
+x: 28d8835f9e193b58072ae3c1622bd01febdeaffe8642e72710b6d67711b82873
+y: 92208ab5afc4d1954a14944b33b0fd56461ed957e29fa356fe81307c452105ca32381ef4bc3419b46ec14361e074e557ec0fdc7759e66798b0b3ec3ae51418ff27014cb67ac96444cc9266078b281136c0e5e144c0f3ce51fb5499590a02d785fe9b49782606c9b0defedc1d7f64085f105d36ee578cd1e6f8297512830af6025a48f1921a8702cc021786822cf661cded5abae9367478a854bcdd812a45acc42f357ff52c47c45f7626ce91eae66fb4f9efda53862fbc0d77c8ce468e56298f2c8660868151c3509e58a890b26a39b76cce20087a7252bb3c01ded879169af8c856d34aaa32b22fe45a2d2241c9b4fe5a0a8b29bd38f320c68a0081273b564b
+g: 668b2d355703381c590ad322d1a950b4e242a946841b0cadf66f12d6396fd6b58be23829359acdc4c4bbf54a04ff4283f2788406df612eb9ad1ae02eececb23e4378756fdcece9ac7acd31802deda157ba69c8d649f13891b0ea9c6ef62e137298a872b3648f8f47850dca2120c916320935c27a0af2faf7ab526fd654833202cb7a7f2c0fb1fb9bda0a15823037770706a7632ba55a7c45160cbad8e6eee5fca7b873a63c3bcee038225592f59417c8cf5c71188bc430fad4eabdc13d64a67605468500816bc84e2f820ca915918bbd64c9d68df25f8ebe8bfdaf2938c02b632ca73e2ad9d2c518ac55c9f180e51a7eef84eedc99b76efdc42ba7fa405822e7
+h: 200
+m: 7bab985f87aa73cc43f2ef2283bbeae11be1ec8c2420a5d5b7a15ef8
+p: d6dc85ac6bd5934ed1f18aae3efc2c4d83a03e76107b32a30b620449105eff0b7d23d147cf55bc57f7dc947a4524a5d8fa24c63f3bb630e9f83b4d221e2f56a9d7525f58ed8214f3ead6504a4514b1d82cfa3e7d7e44e78ab14f880a558909a9a3acb31b1813617e53c4a013c1a7a303193fff2b23beb3e52c0408d668c99fe5154f0d0f86028a34f4cdd5b1c3f00ac082031560a007cd0123847e139e3af4ac3103d51e76ce74fce22c6f69f9a271b253bfb074717ba617f63b03b7afc669fabce6a48947cb63bea9a9b890852d451cd92c1ddd603d4038ec29ae7ba875f013b6b58db60f26bb2954379732fc18798db49420ac985fff6f67312241979f5d3b
+q: c5785bf9837bed46ab904237ade7ffbd072fff7d3808bb64740fbe5571702387
+r: 637b532d438142623060c7cc96579cdf05de9c87bc1808fa3adf704e3939d0b7
+s: 8eac4d64d71ba1884b380018d3f52592d874e71ec4c997de9a4d968c1e1e4f54
+x: 923d23d22831679192dfdd0e3479381fe5ba2caa9d588024920ae7c4a65d8ecc
+y: 3ac9e2a9614232f366fd62195d367d40ca1344a48971b538bbf4198c5b9f81024399fe6838189b8a3fb29e94a3fde501fbd0114cf8efac231c8101c59b770d1950371b16a69692b112a0f9358dbf9b1a7e5ac9bbf714218f495c74255b47ca4944c8daaaedfe1efc6b68a2dfbab94ce76d382a5f7139df50fa515f0cf83cdaf42f6ca30d5ab6768fe3c1fc60ffd2aa03b57e05cf20914da8a8596fb0efbef501579f36c25986de586c217350d01b14a062c40bbf42315b8c3f5e0ebfe162dd60c74ef51ff23e6b516aa2293c560b7795503d4bacf01c96cc119fa11f1f712bd725a73771e888bbe4af43dd545b99b23ca989ec190b587982c5bfffc3b7959d2a
+g: a57923d048b0fc31cfc6cc9497b6a76886dc7f318ef363186dc17aa586011ad8c277b85b453e350d0709eab7e0b64e3fdcd84c0c53ea26a0a2a800a2faf57ec843e9536e0a0554e50d462c4097f4c0f2659cd8edbcb77928d78422dcc602c2c53b351f275f04e328b8775e36409e15be3fa7c067335d66de63b8d06e2329648b1c21bf22778a30baabacc333f75069f8e7a61939ec5007ed614581ff290ca2c7460c83805b6bd17ddb4e281233ca39baedb07b9c85bc72e0d262ef471d27000a0b73f24409af8a7fcc06b2dacb7053b1c6b2c7a6f123c191f3bab8ac9aa3b6e4615fb495744c90cb748e9610e7b734a397e825cdb8905d831d7358561701a545
+h: 100
+m: 1dc6d51b7c7212f67783cc38a6cbb6d38aea43ffab9950e0a93c
+p: fd76fa23c6b7ef204570f852dffeb65d281f721758715e3c21b2874eb0931b85043923e5c8b218fab0d243494ded663438c3c43593c98f7b73cde71e717b6051ba3e621c7a980b99fd22603f785bffe6ce60a224a77dd824afc9840897204666fac84adaf72f097a44cc88c7e829571ddb8d4801cddd690f2ef1b7aecfcb68eed00bfc356a2cf2d77878d9ac1bc128a4aae976edd6ef3bf571c54a4703d64e9051e46a03d53854ac526adfad8e22085534c19f4b8799e901eb553f059ad293b58b3eee61016c3758b45864534eaa831f859d65e05604d6652a26337f4e9acae93f54d80309e81f511beda531b432bfa3a0e3c91978f49f38c9992647521fbd3f
+q: dfd1e323f80e205c75cc95c9cd1238ad2550aa4cb799607ffd87a3730a9f6d5d
+r: 539a84c54c5cb91f1c1dbf819e54eefe3b1c9717745e36a074f1d7ffd53d82b3
+s: 45fa49c386227d1aa799f3b16006061691a8df0064fa5049b5eebf95e0fbbbd9
+x: 169e8c6d70e28dd8f4af3c079fb247844abeab2e66c92e05bb03b02765591d6b
+y: dbdf192cccb087d53a15840dd941bc8921a7b070a118ceb2232e21ab4318fe95a2be813ef961af62bf1fc7b3598b3f2be00aa246b66f195f049fe9df3005934b417d003f0090778ba7b20f0cc5bc18172af14f99d728b3e872717a1b68e96754d9f3138b3724a000629ec5036637baa4c36568ccb5d70bcd50b12516958d59e2cfa3dc67bb97dd959a1c73b8aa890f7caa72c4171c7d1c5ae130b11ec8d161441fe6f8cdd77c323501eacbe53d49d72435bf251c0cb73f83da40c2967d50bf6a610a370c1e7a7a442f47ad793f4d11acb0b5e7dcb6b5487d8e5a037987708de9c1501febf58d2df359469c06207efb573ecb9c44a57db6d227c5dadd32af720f
+g: 43e3bef3a9363273d680b3e77003e3660065b494eae200eae97b547034e4cbc8bc257ee56b459f0981b6bd007894ef5c482af59647db2c2ac58a61dfd478f3a62d3d3b23ef021c5c4c778ba9ce276738e1e790463bbdac810445f7d9b2640a26a40d01504f007b7a63f5a004f3735f7018a3cd2d96c30b33afcb6ac904d81075b9e17f766e3c623247c92f67c8526ed933336a204ae8a4ff9fd9bcb4b4cf7851e8c13125561397b99f50694077663191be102ea36b0e1943b81e1757d96de9ce265995bc6e0d996e93e19437e9b70a927f4144c55aea4f297a102852f1ddfcc7a9d7ea0b6e30f970ad7cdfa1e5ad9f520a8600ff1ede1c6c50eec4764b51b273
+h: 180
+m: 5b303b1a4827fd149090ecd90bb430c81825f9b5caee42b6fbd4a8496084bb02d7e64cb60b261c52e23da6eb85f2460054683cc1d1477cf6d44876bbd45d1b0a516a9b2243db511175e7ec73cc8efd468ccddfbf639149580d69534e6ab9ef687ba9252955ebf7d4a94b99602f2690f617cb41da4f4e1b19ba20796d3129af7f89f03b905f5fd16247f2b8c9eba9ba0206ccda4e964d
+p: e3e3fe78991ce2c2246e556bc8e7f3b2136e837a1f5380b6e922b27475d8afcd6cc06c3b0ce237aa648432fbc2793dd70d8e68c0f945b6da065f8b55e3ef0aa0d0d3c2e17aa25f4136b31eaaea797ef84074247362c803af9bf1523b3fcaccf0121eac658056bf258362d56df0bf4a1f6713e8b0d4000ba47aacba7001e534997d942a684c533f19e3d8c0389e46d429f24f5d2873fb8760d4f3e217a452cab119cf104eb60a9c0029a017d15e0187c1b4e3c7c9d7afd919f596a4f7fd4dcffd23d8f965790a64e5487708f82bc39ec6bc565bc46ebda44ced4ea83e5940e8564f1d730b6458e7f03406f12ea79544a87ce53a6568d0fc87ae715b079c1871e1
+q: ea5381f73a0c9c51c816528cfb66ebeba5335de4c0b5f60855a4c9b8dda6ca85
+r: 8d1ecf1cee0c9b84ae7e7245ce5b82d4ede8e64fe88b073f1ed46680965e3a05
+s: d7aa619d74a0a7096d24c57df2f65efa982891c990c6cf2e562ae573482b645d
+x: bf631840f56d3d5395e2ac67b3406cd78a974d9e18b47c423024063a54d60e83
+y: 62f0d2f831aa5392e483c9408497c42fe0195cf7a86fe516e7cf3cc87db29728ff13841c4668a8de12e22b17cde7e33fbbcd686c731f2b638158760c10e4c65d1b16cfc57c51e8aafe55c049451fc2752396a1dc075df109c08edaf240228df2183bf2e44456e2409fff46442983babfabe6868cb41c221de6a85d06f21391ad35a22ac0f60acc8156f6ed80a45e966d43708916da91a2ed393625510054386e1fd89e7a63e7aa33c5b0dc891c3d71c16d7d8c0610d511545a771fdface741fae8600a8e23c1c47b71e7c9f19aa5e18634ce1f291e60cfedd201295b6d838cc3b984dde522eb17bd9cb5ba3259136c0f2decba2e3b00bb6be4da02f2207ebfc3
+g: 81adf88e3e2c97638faf6d46a80f94d1253e61a57c663839bec900d524c1bdb72be47abbffb59e6483301f0aa86891da547709f2075eca6a93ba8850a5914884b40e2b9892dfb0114813b8c1f69d6fbf7e2964036d27f407bdf7f5c48591cbe50a807590458cdec17f0f203670493cd1d7657db94234bca7f4622fa27942b56e8231b11897412a621edcc6b0b918e357cef742755e1ad0e6ead957b83e8681a2647382cb00d8fa27d1b1d6c0fbfb4a1d1e75266b13fcc470a47f8bc482289a29eb414d8e0ff8c81a81fd289decef24e521ef38acceccd6648e9f81ffb9ed98f68817dfd3084340a263c5a6575f4511c29a6ef106844aaa66f1e5a00f2fbf01dc
+h: e0
+m: e4933f55b9b675fcb83c3d80fad5e135a8045913d207dcb6ce75765b6e61
+p: 93ba1da95cd47488a18c35d86f50de5f7725a5376b67528610da830b98c382618029f80cd4ba90e1cef1e425c64165fbe70fe25ad8e89868f981ebe912d07c153df8566d09732d089f99cdd9ef36c49f76711c474d7b37902415fac96c3c252b05b26f9acc86997a1a537fa9594b943a8531fd285eddff606b7cb27f5a1591a0419d949b7dad706e7fe86d3b1a7714c05359bddb72c64de796ba787cbd9b5fc4ab93966adb1d7180ff19c7765a6dc33dde3c08c277d762803fbec9edfb3bf8a7e6d725056761237a6ccd2d6e24665d69580ed6ecef8a8f6ee78379916e18b6870421c58081ab88af06786f9a483369269b7c6b16448c5fbb24e2bc1db23fe871
+q: c97351037de0c970da4fa95e7e00db17d4a9a7dfa14e8b3ba096ca4d8a9544fb
+r: 38328f38beb6e1117400b949cd16c91fec581ed2ce1d0a7b145bd87f718e55c0
+s: 87880542ed63c171ba390ec715d37e19c54a3adb24bcb3ae42b3c092b0db91f0
+x: 38e85de3999b97019bbf7ebc38f37fc95031417a1b305dbe47d4fb74dbb421d2
+y: 568b63f09f5e296797c7a36d498b4efd6eebca68a3238b6df74a82e857abd7070cf705e9bc63cafdf01f4bff56f55914b682931aed92453b56d2ee51a95f6c36fe90a22ad3716d5f6781176ef8db9e54a5cd62590c2fe0744199d2770b134135399af6454afe5633cee6c3a10304f7f2a89fbad708474c62d3e1fd019a0fe7c00a42fcc75fb1cb87c6e931223ecc105bf7a39bd97131b1b5172de62321757bf24717d52175e1842c795c8e82e83bc028f058ce69eab35a6c52f7b437dea8c2e5423355683c69281a302a3c7fe2c79e0baee4d900453a04b1789875dc3dfc6915b1a51ee9e27ad5fef5a9ba73668b3c8022d01226fcde29d3eff02b8dea63172
+g: ccbf1c7ecec486a9b742fc89205f684063ad0402457cd3b2da6dff0107cb0bf65ae37f1ca3b701de1413a354658be80dfdc4f23a96a7d612f0560c028a870ae2e6a9169088c395e6fd6507ba60b91f1e7652bf1a1db4578c439f317477e4de00777206a6182d66e28a673218822e2ef2a31e2784f9d83dd4e1dfc745287b4dfe7e1e236001ea82d616f67dcd4bbffc12778b663e745a385d42ea3935d42e4d3fb23f3fc5dd82c2f72759c9f304e6b9c991c19a475e7b8403f27f9aab87d62e0038bfdcd4edd3ae5bbc8d2bdf53fe50f3704bfe37af89e6178cbd822e131bd400cca43af4296401de9c31eb448ad2d149e2cc2952ca8e2be01e05e6468b61b29c
+h: e0
+m: 1ee90766d5d4bb417e0d0da721f8b8244ab8d953af11d2e49dd5f6ff6b0fce24683624d8f02804d5418436d67d
+p: f99b520623b031b47705f0e35a462253d991c7dddee70b481a78242a06e5ed9063a90d91e4da80eabdc649c080f50a318f4c64a52ec964aaf791cdc763ca9d399b504783490d335475ad8f93035b6dcf3f9c2dc61839cdceb96b4215ba70621506ab3df9e217a27a790eed5dc8a56e66662bed30f035482fde7f7a491e4832da173a82dc06d42cf669c0b56603c3b618423f058c6bb3af28ea096fdf1c2063bcd93c2221c163dce85d8d7e1fc07c7e4893213f5105e8c82432afe71202710991bfecb9d1a94f679d8298b8b0d72e0a5fafca9da0a319bc849a550fd94fd66cf097029ce945232946761f3193f55089974ee6c0f246706c7d33333f4e3e94ffe9
+q: ec1ea4367e635f9bc7771b596e0915b14a4eb6fbe11f51925dedc33e1946abed
+r: 44c3edb144027f081106feecd6aa221104289c1befa714720746e286fc5e0812
+s: 2882edb4fd571c88d16011ad92117edda814779110a761eafa2227d0c7695bd4
+x: d2ef5fe4abf800d6dd9ce2050c14651b9748e49ca5cb79361b936be9a181c27f
+y: bd79d75c6b6e2f84a0c5fe021ab7f8914fa8e2e64c2018f622ddc44b47a4840673016830f6cf12a9c0fc81a76d1fca5b46f799f74ff950e17684331a88ada8e4d9d9a886112b4951b80575ac8ab63afdea28239e59f3560b2f981c0b9fdf8949452ecd9a2b5cddd7de51002a183609da4a1983e85a06df8d647e02edf0af114b1a5297de207ac7f603e6c087887c2154bf539f2961b21c9fcdf2e558367c2e5cd6ddf980cd96a6fd6383e793c57c6277fdc317a4166993e534c5e510d74bd6a9995fd59be63ab21ffaa31fa67b575a6d954123d549dca60bd84bf5866a3118060c9a4d16bc89c137d3392bde8afd49369e608e1cfc9524c1f8b07e467f466953
+g: 48351df7fdf9f3978da9ecacf4daeb1c73ead457d9555e6f2ee402b53fdc4b3172e9721c31065f6860fc221301665c78800370c408be1a353fc89a91f72ceb466df8d289922b13e8a8ceff054d5e1e379406f3b10ffeb41906f10a61ec87efccbcdcc6ed2a725f3c15f9e6a9811311af65a30baab6999fa84eddc56c67c0d42145f17e27f867d4db2a7d90ddf15efe328aaf77fe3b8173a97653dc567ae5a773c2e7ed80d63c05d553d09b7d4e6f0b67c726744de469d72be0c92c2f782c55c3cba5e9538ba261cb4fa45c537ad17c10ad214723e4370b46b141bd2b8f617592274eb0208b7134ee6f46bfaaf077436e39d9c7d522fd1e2f68179c3362f0039a
+h: 180
+m: 432d42b307829d3ae768e91e63e0bb09ac801482df5185348ce7e846cc99787f20313629ec2a4ad242fcc1f2f147bd056a259e92b18edd48de9ce1a2bb703b29c921085306d580c8b1b5fdf22539eb5866ccaf4910d525f5de4b1f1bb87e0915235ba41e07870660aaa5cced774fb82f301ab503c1eeea130f
+p: bb02edaaf53bab2a89ea97e20f971702fe4f2c8782ba67ae1d3809ab1f4a2df3b53104ac3740581cdb4abe32f6248274c3adfa6988d7cb51adac240d269a0f66189ab9922409233ab7b9c9fddc9b20476d59890e7f23cef3163d2f9745b4ba74e2b348b4cda62e35e16288870fb66c4261ada907096a89c9b66e949245797d2ebf302c3c4471563c28c8ee330f730c527d0ed148e88f4f210d0cc489ee4d84977c9c92b832e8fda76540a62b0ac611b5379e2e2ea446fe2295264f988e1f9ff0dfafa3825e4acfac3dc09983777e38e79ed579a0e0c22c83a6d884caab328d08873882d0ea1ba7157728000be7a5677fc7eba4fa174fb765f1da6e89b327a823
+q: e0f83307910923c476232ea2f915a421f8cf798b48d5b39a95e47aa9d8888811
+r: d95e68afe6dd506e9ecc3629476f75e05ee933310a4ae4c5933ed999d3978cf5
+s: 6e213647f17b0a9eabb40116dd89926ef7fe7c4f3a724ccbcf9e365654d3a065
+x: cd1afc9e55977be18a95504cbe42e4cce7166479a5aa1581686316b3c046bc3
+y: 5595f77de86023675269a4f8c77b1d77d2452bc3a1dbff78b8867f5eac782b96c76376ac43691d7e01ee51e4bc181b4016bbee4d44a8a965ce09f2aa75e134ac93ea8ee3ef840aff42226274988b1e157b6c73adbec0fffa818ae9eb623ff453a4f78fb4d412fba4e4751d95cc3eced418c3c68c81b46e9185cb8b6e35a9f052840a18c7e858e35c260cb19b582c2e39075df1603cb773d685fba9c4e23fedc712e858975de18bafe80170abda2315f682f32733bfaa3b23df752117c84afa265a9f22cad5a18ec9a4ed426cc3813187664b3588183c0c0584f0593b17a3108746b88407ad6e29ae8cf75509e2719a61e235f203f7e1db0556b7ced873f40565
+g: 5325145ccd3397a6ad5c7dc7d13716cd0fcf3647d6a8e2e6eea6f8ec3071d326f09d1dea10c3ec6deb392e293550850e1bd8061759a52f01d84675c61ccf847d9ebfcd740f9b15264c04db488c6d115995bedd96c647ecc8789a89dbfa51c44f23a2bafe7c61b6f97a8f35a5653900168d86d070ab2f7982d021c1f7623516d940f3948774fcac16682d3624ef353997b3c69d8763f3d142c4ff0e6d734402bcd6823daf54684834947d8b9258a5d7aed8f17004b1091d9910252ebb2dc10c95d00b5dfe57e861d409d0709138aed4b505aa5f6532d99f5d8b687ae229e0794066bef5b9e7f1548a9290e2e36190595ddfa2062ef9c70ca77d6705781244e6bd
+h: 180
+m: 57f0009f31b02b2f39dc808905f901ae4dd6cb966f1ec8020da03b4e038366ad1e924f6b95b693a032f2bfc694317c773ef3cc67a0ae1628a43132b2b98889ee2f60ab4984d3df13ac78235a054913ecd275a59530298f704a4d2d78cd819c241a5b715842f997f7
+p: 9065cadabc0b92fc25d2539558a79e14c31478149b317756389c929ee4d4c0e286cb9b8670e26fd8be2e59a7aa5d4b99905225477c6fb689b10bf2414da2d15ca8284e9cb2330487f82dd3336b5e226464c0c4494a2b60c4940974959bb7103f2ada7eb1e1e6a01a44e3ddad1015d8729857439017e1071a09078f7c42ae6bc7883afec3e48cebc30a96c8ccfbaf945662d68eb3b371b7ae010b20ca5e89f8aba186dc530baa1f5d478d75cc26df6a728ec9d48d177978eec9878b3209ce85dbb61d51b6462c99c3072c70ddb25d4a7d8b54c32f9dd4a29efbcbeac4ad9f702371cd3fc397a487b6776d1716567eeeffe04622ebfd556e3b36aa49ce030fea0b
+q: f7c79f3699bbcd143187f294e146c2f431221776c972005ba33c6aaa02685967
+r: b5e11ed1ca2553fe8cd3919eb75c45a114f565dc5cbcc180aff64e5436de5f1d
+s: bb73508ab4c42bd4f0b0a3dc2304da2812147290d18627cd2db46ccd3756473b
+x: aee54b7b861818f42005590e0175c7725b4d27cc6b7c6cd2a16e6aa825e66d31
+y: 13547903b97d2ee62dc8bb13f6cfe1a4e6903b2677580ae8130703100d3541867575b366338139b304f624cc7989e36a56bcd8d47af002f8f3f6cd79597918f8fb202ee6b8a54557a0cb609af53a52254efcae11c3c528292c0ab4dc983fd88243cbafe92411ec410d24cf1a2a1232f875772d609a3fb4a6bc4cb7ad0f26cacb90bbbe3c3da0560c21c9e2024adc63d1cd15415edfb997d25fc5239a1c84fdfd970e40aa590241fbc50a0d9f5fbbecf32cee79672c23d9d9ccd6d36a67297b694f6e90d9557c82a25f06496806571bcf97ee32870e97675cd7419c2600f227af423a0cf8c44600fc0d0839cbfb6e87abb6b168617af5e1ffae0e7141fcefa81a
+g: 1c6ab6a5ea4120f9a1b50e5ce1e92c2cf564eb8b7210a8d3f61fa1946b152327a37a3a5af982911704972f0af2d04ec1efe4bb799e1fbcb1464d60a8cac6d4b634453c818adc464f4b1d0b076b7bfa2e99c6cdb80332e03325125610330693406d58fbcdf46c9f31f161814059e2a7fe3891b7f5f7792327ad4e64865db8a941f0f3a5feebc857151df72aa9eb8979c2aeb37af853640df5f50b0b1221f51a6662481e5c654e54450af451408d5cbf739b6b616ed0dcfbd08e7d2c472c3cad98a328ccad65773a6477b1169dd0bfc03d4a5f152f0c0bd99d2f262dfbde62028d5f340425be6327ca0c303b93b19a274223b9ec630a2788f95e01fb9de882ddf0
+h: 100
+m: 90040c27654dfabee4648fb0fda74ddf3e0c45e93f5ec80ee5322cabe34c9af4fafa64fc25cabee79ebc2f08c17deac7344ef2a555c095bf9dbcb4bd1906a61cbb1a8025cd905aa507811d1c6328d06518480af605995393f58cb40687a2b76508fd8f5f8f6b4f633b217cb541f7858d91ea15ecd3848c46259af811580c995d95520af50848f6f2af1fbcf1e9c7672a5754e3dfd82a719f4f64683d40ff
+p: 8393ddcc5144683aeea20e34f385c91c2b4046bdf95436afe2db1938100bc0b5ecea54bf8299c76eb26bd3dc77c20b216f058ffb597ee88f97aaf439a7309e5df72a012fe3b47d6309bd409905fb2a8b21567252b6148f246857829e904fb7ff74ee466c5d860284aacd0d1350dd78d6eddd0ec23f5e90fb90b296dee94e9735e0ca3fe9b32124062e495ff6c6e9c2b3dbb3e770e3eb752e76d935d5c88a93b28caa9be40832ee9e126077fa1b416d9fae155bc80e85836825e280722c93b8b545a9506b35aae580b57370ddcc9f2dcd6de99098ca1c26ee066bcee8d9be06b2bd8ef89cd0e987ccc334311749cabeab4cf100e71f8e30f26b189cafcf4c2549
+q: de3b45a2eaf3cf6f795be99afd0c5542889920dd4d9ba3077c6e4158a83c76cd
+r: 8c9913b740725d9e9456c06dbbdf61952ee4bab60611d8f26df5020c503416e7
+s: bd4a5b5c1fc798b02719fe7c60359392ea964252919ed7b41268581601d27b65
+x: b55628105401645cd7b4f23e01404fa50bf21cae9ebf4d2229bfa0587a5c69f9
+y: 5bbfddd0682d02a5dc85520ed73f5dab6d7309a7266f346e6c71b51b95c95e3e00bf76d54bda998a0a1ab27cf6d1452b0bb2cc150c1d5cf7ffe4b2f6ebc3b70b2923b2895a6df5334d2936c505b71d97229d8358a071cc3dc996eef4a3796da4e33835df333477f948454f97235eb27ca987eb6333f8a1ab6fabe4e0301c159d3158490609f97be276657361400e9cf0d8cf0bd7ba20a43dc9f361c4b8ad28d9701ad11f1adad49fee84b3483105bcd4e1291d2b63b43ea15e635efa60729aec4c75c48fb99303b5dd724de8bc58d705ea9aa74918aeb064830071ede20728ff6707c3f7712a128c7d1afb8f97a39c4dbec05bac437a56bf010497861c165ab1
+g: 1848533eded65a9cb9c5412c676ed122a594214e629f988e395fe76bae037eb4833c682bfa5281cd43eea170759aa77c9f3314877e9fe9028458a7eacaf8819c75c80af6b7d4617b77f6cdaa552bfb72b1d2a787269a09af3bdf86139a5fbe134f4bee79a28b7cdcae9a6433f424c2bbac818b823b800f7d60984101f6cf3c9acbf10acf9ed3ef9b9144adade816b7f530e18ebf3ebc732238da202d2c67a45af0b43efc05ec56b6c329358dce754cea530956be1d8d3eef7332b0f5fc5c357392d0c6566cc7c9cd291031b4a39086206cae3dde9ecd688bebe64f4876ec166c8f9b416c674f778c742c2986deb73e2088642805c90dd875488d3b2076fd7a13
+h: e0
+m: 754ef844378a6eaf0012c21e56da93472016e18415a1b4f3be52d8f753acc761fa62ec9b55b1546b4a119a7a7d7832abee73b43e38849d6b4e80dddd0763e77517777d0ecc6738c4cc5642bd222a94f6d037cf6a1419b6f09219d0f60a2ff2058214eda706ee81acca9bfa35e4cd77b9e916e517527a76fb7b902a74d4c0269bf7f70495d18870aa0cfc5e8d852a2918391363993732344b1cf4d0019eed6105ce40f520e2b6241f7ed16ec41b26e1e4bade975d88af20842593faa1fe5bc43226cc596cd519589edcaf0ae09cbf75867e7ecdb393949fd07589cabc12e4aa412868a0808deea6f6fe822031c8b048c46586f90e1d40fb5baf9210
+p: caab54f6aaed4284181218e37ecfc6281bc96b0536abe85fcb87d59fe64dbf0cc9a14ddc11662ea21333af005d5b18cd34390eb4120b1b768c13ebf0e74b1bdca75c98566a397a5ea0dad6aa70a04496ee96bff77b5230a6abb407bee8b5bb4c40624d7fce6bfe6d227a075d6915207a769be8c70da9d474552e1725201e96353d3b800716cc8723ba834b5edfc29b7df32f2e0f9cab49d40147b29ac2dc7ef398f300eaa1a81725fff9941b15dd6cc46e3888fdd6c8f2ce5076cf0cf7e93a1ad0390344df8fea5a2b985da2241dd2e915cffe90e16328217aaad55eaa254abe92684c5074ed349a4c8c3f834da27b69d3e5ba0211b9813e8999d9f8ab3e9ca5
+q: 9ea50697e3c0165f7828a7fa5983183df26f6d30091bd2fbd344e2fca1348447
+r: 803ee01a33ea6d32632bb9e4c73e4ee61e32fd041f4041d2f5002aea64906e48
+s: 8b88c04717fcd93c02de19aa6ad993c95c56d9b11076b7834d578a266a45220
+x: 356831231ee1b8e3e740e8d4666cd873d2123f8603135fc48c093a06491f6258
+y: 41967640b7a72cc0bc2e0a51f09cf068afd9891f0bd7a62c5dec07b2a5f025ffbb09151a6f3ad86bf5f869aaee08f478085cada07870726992ce168720cb26207a204f9fd701258bf51081d0827b77e6e857c6a40a467bb9ed2f3bc83d8941ffdcd9b1996d0452383e10d181dd263edc3042cca53b39f1ce1a2ab2d9dcba5b9b0dcef9bb07f28559326d1b41b037e095aab087f89c2c6f693194ad3a8584b210ba3d6c42182e545bc58404cc3f9d9e211b97437a44db0acfbd741d3ea014b65e742c442dd5c7e43c139bcaa561a6d93ffacaa9818697430f3153191da6b0c93a94363aa92543222e735781686efd0f866677c71f2d2ef11d997ac80cd2945eaa
+g: 456f174bf581eb5aa803bf41d7c2a4b4f73a73b990535a3c44729d541a993ed3d777d42769a2ddd0555de29e3f392c3486e2454aceddf7bda99b095d982c3b1f8c2851b8da98112e0f262870c07fbdad69b005a98a85172b51175f27c063998bf9899a65949478cec6baeb32e2b663044bf966be9f6e1fc5912867f20c89c97da296ac045c3c0ca5520c86181a881b31cbfdd4653af43feab8be1fabaa7165529c61b902ba15c900dbf9c77b21d3aa16786a95a9a060b80dd4c4c2ae9fbfc1c3dfd261c572322cf2d506e4d3192a82ca7c54304f41e0ee7e99ba5a6ef2c3a2aa236af65f9a2763aa14d1e92e55d84df3db8ae872d90647b248fc8c235734a157
+h: 100
+m: a795800548bdcccc9929189cf9f449f84c9fdc2d3e320b6556070d8d98b209b78a1cbd7401a9392c55ef01470d5477b17ae10ec6531dc88f739fc5e5cb37fc3586f895bc27845cd24323cc42d2fb3107
+p: 8d4d239e83f4c07561a3384927c0e6a2a708d23b581567d8d2b238b48c8dab7d86e8ebbafffd1f383b20348c974574c89eaf2a16688b0321eb1fd44835375047b4e7d1c4303d1cfe12e260fb8e61153e5cad793faa7890d10fca1ad28da4daf76677888d1f4018921d46c4b63299a178229fb2c68a3ec42bb73f5ffcb826f502768de68c8b740da5a9cb63b4e7760073407b036eeb07e561d4035e4a87d467fd7560c969e1ad659d311c474edd6d526755c7147e45a2213d0d78fdfbf3be48e8aa2a7fcf326d24fe7293467005b9eb34c58a9891224b060126e7bf29b08694f895bf90fbccb2fe1015d2d8546c703355b28c080b2e41f0795a6e7f10030db24d
+q: a136471f4322665e90d9b67a5c7f9c3d1c16789ea5472c245d8b22eabe645d77
+r: 9a0791d875c6d524b7495b3db7a076018014967470a64c1c6d54cc247b05298f
+s: 2a5a22e5e30cb81516ef1d3a849791e64753696e81556e2b3d9a0a2af5fe4064
+x: 89b3ace84682a71bbdd0e8c2df57d4833db6ad87c239da2ec8c920e09dfed5c5
+y: 262d31682157ba1977e7b40860943a03bd34e30c972b12c193adac02064c16584b4974de432196972b2e5437a5a9e29986fa4121bc92d60e2116fbfd855011dc2dfb66f9f3146b1f853b34f79384d9df378f5b79820c4965b92c45484538ae0b50c73d02cce5024318abc6c27540c2850d27c06326f0186bc1a46992b2813d27d82c5ee8745fe957efc6a6e4b84fe9f7013faae634327dccfc792ea03ba546e44f2634b4c0cda9c3603db0e84ccf7a191b05ba579bb662bd98f55635e12d3fb5b4a83f219be3bb6f989e165ef91c15d5fb563fb670f758028c136bddec6a8a12ab794909b8cb4313808947947c2a26c69413d3a90c40b7c746cfbcfe499a7e49
+g: ac2defcb4fee2c630cd5a3f23ba39e4ffd8202e2f9ad64e62b6cbc1711ca442b9365480de72983da1843d450decb83f2c8c83bb105311cd6a905b46339fb2c6691038963741f1f18ffcd253bcaf35eacd52e27d16783fb7743ee2c7679cfe9134c666b24f0251050c0a0db0d78007893c40ab6afe58eb6b16b38b03abf7df38e8a3f948a4dfcf8c5fef8a98eb6b8421c8594b72c24934bb86851bc46d38f5b8ed98454327621569298675afd7f75c92b62e2cafa3ac93051cfcbfcb20691026f3a731bab4ed261d3f1a7a83b77556bc2e297cbcae6cbb1488167edca9221f50d62320c681ae7542aaf44bdbc4351aae09889efe4ae3aabe252090ed92b0d410b
+h: 180
+m: ffb4b22245b0
+p: f0327019093c33acd37718c7acc74d8fda79aaef08c0d70368405f4b0ed468aff9d08b0cfa24c6d74090e54d243d89e56edaeb34728fe8ef61c4f58a935cc70b468d9fa6121272389dd7afab64d53b8a3c06c632576dde2da93cbd496dfa4aea0e21180df056a4a48f49498f2826cfe11b6db29a2ca8d6966235202aff8803a85f766827572b296c2d1f4d61a230278cad46315a63061a97f10387a8f04ed49f2f051d5f5fd5d2c5bf4ea175b13c699de0fceb0be22d99a28bae583cd56317c4a68ce5c174ece77e07f6c5d8ee9558e233bf93bf835341e66f0f7d9205dfad9bf6bd4f200a64aad7d2f74acece12f3c14de6ec2dab43e28dd3550f60ebb84105
+q: 8e54333a23335bb7cbbfd4f135a6b5fba5e399f08ac5811c4880185e56346c71
+r: 8415df996090bd19708e0e3d65cc47883c9eb326c4b811c05c9badf74e211c4
+s: 2575fba4d2f599d01b9117e1ed78152363ea8a332384d26e9a76fd281d931fbd
+x: 4000168545efd4efdfbbabf7f610b4876e3bacd9d30acc0ce6167617af61efa6
+y: b33b29f2f73f3a76fa1d3e825dee0b1d19255a7461d03b6899fa274fda205aa69c4460a4f8a52e34b9a6c2897ea04320fa2dc522aa58f82a8f9f5304ddfbdf5c65939f477776e0724eda0fa57aaf6eb670d0cfe12afe88ffbbb6aaeba4642d9213fd34c383d1f19d85b0095216b0bb7a79b0111248bb2ac9ccf3a893ae4ab1761a765dd96f8196fcb287abfc21f4125206871781351f52ddabbdc6b59cb8cbf8060c9e0c3162158c17db1643095fb80954673848d5cdb86b9d8eb948ae8b374d754c2764de4c5b9f661c8e838749c1c5bf32cc9425492ca7ee2a7e8f5781090200be139919722cc560cf56606d9c768002ecbd7c0f4b201d25bca9fb4e548377
+g: 9a598a0a3c4dee259bb6e8292a7c751dc20caf8dc4f5461b8565c7520f3aa9152f6515756be980fd4949f47ac33c1f4cef115d6a10234f660cab7d8ecd22be02cad3fce2f7eace400357d10500a75238231aa573e66dc28e0538896c22ea35c5c4ecbf75c8f73592ba9f0f5405f3ed3df9f5c9e66043d9ebc49aea812bba086217bf33844e164e0b3582db92f253d904c867805fc916a6da2bd2ef1d85d7d040a6e5d1572a4dc62e60b65d954cc27b97e546af67a747cd465de00f6160f7469f3aab386bf015b74483e14b34d25bc628718cfc03fb8a146a437486f0941f070f9ecadf3fdabb86a7071706066735ce73652bd029f2d767a267e2f03827ecd24a
+h: 180
+m: 6a347aaa125c9797ba875d6fbaa87497c636d6224ae0bf1db7c6ad21604cf4cbf6e7672baf59c5d75236a677495bf447c3a184c646e37c0956c2b4341bffef51a800db2f7316e02f9135787cbf76620855
+p: b4240e6680c00aa99b3e93b40931c516aff1b8c10ff8abdf820652ffaaefb3c2098060c65372a5c08ded509e7405e1e762ce633ab0a372775627a22512514f1f617a665e266196a21d1e6fbfeb5cd13caea325b930251ee95bf072fad364a4c29d2adf06f7bfbdb70708559df40118ed6d671b16de353a067d34075c3672f97aa7aaaf9962a4186eacb28cb7400bc3a6edbb050ce0a7a545201fbc2ec8aebae31bbbad276eb7aeacf3fff8004d252cf3073922239a38703b9871d83d1761b2015219dcd3d1c1619c5dfaa7383912a15bf5eea43e16165fff68fd4214461cf01b2e032b6bfb81d383148cb4534237f12b3e200939dc7888a59fd7221a877f515f
+q: fc194bb7eb92ac7c8ed3a037bd4235f3b84cbe467c891308dc334a46dc390a79
+r: 3b9161c216640f29617cec2de99cda72821f799d3ef214cf97b02b90e3ec6cc9
+s: 50a2a4a267baf151fa2786d5d5cc29ec9fa0e3ebc644743ee690f518f6a12361
+x: 556f999b8e92c2237a944686ddfe40173c9000ba00bb5dd8ec11ad34c2462d45
+y: 6af6d0239be012aa6478f4e9aac1b8162a112c3e67c81f11b94429a548651444485aa108400eb55079f39e75ea15d730306feb6c190e6ab2cd5d69f481ccbfad5038d1a5438c0e34ca8a426b72d582296535b8c5926e365fa2022a41d998d97e1e3b56ed97596fd5cfeed259367b7b61f8d26dae461bc40fc8bc9b58690d28eca2a3053d7c541dfaf3004370119c176e50e59e13d47ae19b4d9221f568449713c985cb66b5fd951246f76dc3f3b35c00543986ab3167090286c5a1e0f1e77b10de6f501d401c531e3422c265cda5633e6f912d6b6f70e7e48395921beea595ca656affdbab7e24c1ddfb37f6415e521a8795588ca7c72b17c6558ac9201c5179

testdata/dsa/signL3072N256.test

@@ -0,0 +1,234 @@
+g: 49e6930d809a1bee01a02f9610d983d22fd44c0b1f6a2493d801c2bd1dbb604a0e962c4716e102f9acbe0ad7e23a051b9fdb60126574e62c287b35d4531500ca3b7e29797abcf2ab583f7fbf934f3f8fcf0e908910de4932cec237384629ce7f088d40128d55dbe83f25491d6cfbef103ac0e129f941d278db2998f7a7bf7f9aa21abff054dfb9af5602325957c5584c46c812638f3e71820e5f7eb88bae8207fdd62498408fe300e591156a38634d64eaf6d696dd52a44ef451af1593c65788ff8105e7665f6ae68c8f2c011ea964bd839dacddd5857fbb9209c2926b275a5bb7f3be960b28f842e78a600370e957ea1ec83bb5ac2d3e9fd58fae0275f794b76ff8715e67e70c63abb53e2939945ff35e23292226993210fa3f4aa1e512dd9a9ca245a7552149e1128e99b4f30bd4f48f181ccb33169f599787e27ff31cd04d5dbdd64e0187f89b821efbe11b3d330ab420f0fd7c44fded5837eebddbc818670d686f64f99321be8942dc6ce3b12bbffad3cf52f7205c4a99e65b5bac86c14a
+h: 100
+m: 72c62618547db4fdcc9325ffcc1a3ce1cec5fd9142053fa19f81d0fffdc2cd8ff21dbc41a44a6e36eaef7a7457ad268ab7d1f888b479310a526bba75a82461ba1734326d043e97b7d4b22340ab592b4546e02b2ae695fa74238859d855
+p: c4c30de34f5303d4dd1e318d8a3be4298f176aa8108554fe1a1a0498def92fff2ceb40ec45c0d5d1397cf24ba1aa910cdac68072a2bae7f793bb991744b84a578c9bfad192ce2fa4db813c90ebe0ad1ac44023795876b4d8969097b9b0caa81a65e404e4b5636daf204fdf63be249066fdc4bf6af7883e17e3b33d6bbe3b9f62b520d9b357afa25022da9f4f3ea3fdd5278c915a0ed2b8947acb17e98ea83990c6886de1af20a42af1503604a2c7a8fc60167d3401a3935b3a5372a885f33002c3bf280fe558f46ad133111a12f706dffdf313547bce8f9834d091216e64620099acf82c97e42f67d65afd7d68ea36bc4680a3ef6cb5c08df10de7e6d2b75c011c3684a64f93fde539e3c11789342d7a7008e0a82102e1e6f625f4501ac253b4969c1cc3ee4929ef8756c58e512a2e8de70a21fdc8443e4ca29a7a05c2ee8cce39000e9a0a7f8d84a6ec48ae2088667d9c02b89304c3e2a51886f36d70b5b0cc495a12157cc6faadbb576dbf169ed793e57a40ea017b3a8d1a2baea86834fe3b
+q: 93fd71f343eb63dfec7bd52546ebe25673cbbc94524d9caed3bed7d75cf98313
+r: 413a490c44d018d26ba8a917c9566be316abc904fcf354c04de6715513db477d
+s: 75d30b6411c4bf3482312b9c52a52aa838f1e6d5551f92363cdb3f69d2bc66b
+x: 357c61bb275e61e191abed4ddaa37c6dc4f0afb9f00db99359d05d087a9de725
+y: 3b5bb87c8f72459d71e3733ccb196f718b964a7dedc34791c29578a6d6a94941325b210e1dc8b071cddd428c2097a43c9d51cb10f4f2fa216cd4c695e2dbc1865bc143a6d3bbe747aec9f7738507a7d0851d482467723fc6f04d521b5e057e254aee4a4bf557a8d036695a945ec0197ba01d2080272a58a3c67bed7ab28cbeaae836b54e39156642e07b6d4c169798a8b1cd2fcf2e2121f1a835f7a55ff3c69c9d93c4091a8ddc25b6996f8b0247e574d65f42c954e62397d9df72ac3dc42240331c398fda9b6e685ad306aca2c8f18b280c58f9eeb70c38d89a476ae143d759b40f0c07cefed451d9e417c6a37fa5e0dfb7e549e5191cac63142de9a292cf753c7b400049fc8b0990b4d8b242bb6584966f1b34b543df6f2699354826a959d6a6e9cb02b7d402a71a17c178215175c2e426bb3c563848a6d35059cb077151c83d144886fe790c524fc95a670578712fb0a3d36b6d6310a7cc7d260b6cf520b15af3bd94222b0fa08fc8e1921cab8a2754e83dcc303578c187361eb1dc7588b8
+g: 5aa403d7788597ea2bbe63a17d69c6ed0a9a9a571a4df72244abb9002c7a3f7bb0afe5a14f3281b639ed331cac11048d60a4d4117a015e21d2a3fcc5d2c0570499527fc3ef1bf9790639d55a17d31bfdebd6075b09154fe64e5928c68b3aba6ee10599dc45985016b77ce00c0a3248e0d57293dde97c03838de71c7971e8642c94913b16ff51096c24553b8da426d969d8c8fc2d99845b1952b406e46b19cf411fb558f8ac25d357d913c9e828e497a07e074f11f6a1860443edee7349c7a6417298b03b859e207367566ad49f40f0f0b4e4b5791061da9c28ad6765ca55454f2db058e0ce98ed5bb3e539b1bdea7a57c19d72e5e752770dce049483da079563b3aec0a75424e641bab2ba2deda8f86ceecb1ec26e962917c6e1461592af99707cea6c46395b2d110508acbd3d39f9e386e5f374d672670ab50815574ffe6d5c20c5f08c7f7955664d603b08165f58e817448945d1014a177d4058c33c368583f8c82c55197ce1f5e9e9c8640d86caa97c1de73fdabae3f9f9f1be2613f2c0d4
+h: 100
+m: 5e710084410ddd74c90d018900f7001dc3f103da35a239416fef6d607b10509bd623e58d86cc96e72d6279f817a839d888dbfe8fd012d6292f
+p: c7bc869fd2c584ffd7c8c93e6072f4dd2e32ea2bbad9e99608c510f2a9956bcd61d418b9a37e9388af66d2f5780d328ee301fb4361856c7ac6aad1d1b8baef0c8c113ea7dfc0f52a079d874419b5226a55dc7509cb0e66f02efb503d6eb43cde8610783b564ba1ad1306c8c96d6c2f40fd8ed10298fbb5531920c3394921d8ac3f5576f0403e1f59ebdf074c3fbd4f3b730e246b55577e97ea705e5a39327688609694f35f0af79a2542462cd1ae4c02319c31b264b1d2f7b00271f4b246266a532adb513bcf18f21bea3a48365791fff11c9d50d00e2c1fc91a7e084a4e7725c0b2cecc01c2c56b9a438fd81629b6cea9d799072e5cdc6d76d69a5949f6495d6dd5d2d2ace98cba2b369f495a4005eb892890eb8e0a7883e031e7991fe9217a9364bd8a1e9563236e3f9e3acbc1683e9cc882ad9082893a1ab84ed618ca0caec00df0143e8aacf9b8a15ee1daff8b2861e4693fe24a996ed02260a229cd9f840b404f9b733bfcbf39d9d5eda6b853401d8b6d9f445766355a6a166fef281f5b
+q: bff801fbd536e6a98417b4ddc95475b057c130ef429746e699314195a8149c4f
+r: 17a1e5fa55e4cec816f26f373670dffb595ae3ec1aed98577a57adc141af68df
+s: 7bef6a5af8cadeacdb1cadc04f5d14a385c842a4e68c42690da492ff90e72b8e
+x: 797b3494b2ecaa3c50e73e6277c4d210161c8c412c33e10f3fd9e40bbca75d26
+y: 9411c4322f0ef3ad8749137dbba75a2a61039a5505fd5dc6e48269a986ef5eb9bef783e2e1371ae047f69cef854e828bfef4065d80bd8d4059ee312d33538261131e9f2fd74efb4ebfd0039113b1464c45278708010f015a56debd171e39c0abfa0851b54e7ae3597d43efbd755a0ada48b5afe8b5a58077573bbd8c2ee534844f167df810d7111268bbe57d2fc8ce3b095e41a45893401f1388eba9601e444f503647ca2194335b6ce4db4fd49d5b09c89529ae46d793882934d22cd20704be20f725a87a3ef485fb8b07cfc8bd2c637353e71a6d1d76c69098bc0f1152c2bcb9e47466dba385e8c0ed4eaadd5fa2452897c172f3a9f5d4b298bfc1836ec2bf609dae39b8a60f4f143c1497575038b21674fe86ab1b253fbe689a180d7d78dc941a503af4d404f4dd6aca90854e9c801f848dfedddd480edbaf1c0436dafd1b54cff84f68e7667afcc24235d39e2cf27aea758d068a80ae95946e148f9fa2e4d5cfe32a6caa918bf102a2f87614194aba7d305bdbf5ed3bb8753b5e76cf37de
+g: a04c7eaffe0785ea3d39a553a2f3b587a3621bab9d57e0851f80e6e1856861f0d52ce801a4fb74f0c70719914e74298c49ca782182c5e692b5b834b01f6f478acb9e82f9fb0d4e484a030516bde61b472f766be8e7ee3dd9116c151a5340714b0cec3a5ee97b35d291aca3e0dad582cb76921053205d318537360b12d4724f934ac150003d0868b5729604974dbed08cbb3353641211f36a6f4c060d304fc670180cd15e951516b117d7a2848da41650cd66e59086a2351c0ad91f3c815c240d212ad06beb57a36299781096fa8e39186aaa6402b35a380c14f2bf6cfc2ddd78be2ca2d1dd727c14252d58c7085c412dd3596859b8c57ad1788913c3371618c12bee8e2c7c4694bb930fcec749470ce260530d701c42ff662727709f16efd4571f998e05f587ed757784ac5e3a87d631d08d853a317d5fb5a095b1c71cb998ea5dee72de0776d17c34168b3e3771ef9b8d6314f8a5fcdf77d50dafb7293dbbcc5c9bd538b2d1052f2b6182232b245a21f0d4d36b476887621d8d2f95899c3988
+h: 100
+m: 8ace8c6ec04b9a1f02de5843fe58329584c841686e7909ed153ce78f3f9ba2ae60e7a5efa84d6c111c7c68bf12910e
+p: cb8384ca68625ddfa6eb56f82c546e784a6b7e67138b99822205925b5e293df684ba9f8d81eb9e9fe6a08018a035408265824bb0c685fbe688c0a16ae8017e07245defb51652ee9e80ffdf847fde3b4b8cfaf6df253ab6dfec187ac616c459fcc3bd53f0b88f2a37acc8b32fe9f5efbd6de0a866d261315bec005431fc6d94c004c69c71317f4444136308d8a998d276694d7a6718aed4b345457ff92406f00359a96afc5a017c54564d0ca8a9d1d1396ea948c1af2cdf775d4cbb02ceb60379af5f90935ba3ae858d0a0ec382494fed50202b7e19350073e181874157e2df1c652c100232c5c509011a4f0aa3c1761113dad93fc051ee064573484385efb9c3011238e57907921c92201ff6588f7134beb5175fce89f7891f576a571fc4eaa244e418f858f25de8c99fb906ad6b8839d8c4beb5c3f4394fba1f35ada9c9babe6419809be6093fab0f42fb1d2d4cf82d563f7c128e90fe4bddccc6fbf94299d2ea6173badb6dd7f1ab786582b528dbd03633fc83fadfe3874b2ea597b67bfdb3
+q: 8a17ccf94b115396dbdd6183a9b08e02c89415749da720c9c09319aef45e9521
+r: 6301c9bdf8ee8ffb4c8e8c86064c2b0f45797f1a9f68b0715219112e9e4667e5
+s: 8532948e6e54466883a59d7792d5a7937e9f3be961947df48e7c3ec1c3ea064e
+x: 3ec4747e545c0fbf8711bec311f02ab9ff2c1037799550e93a64fde643f2ce1f
+y: c2f690b036cba7d9a7e930bb92b4da8daa9aa7f8325c5870b5bdfe3d1a54a446edad969c3cca59a3a09b458ef857d676cdc09b0941958ec5ea3e3e2756b2fac5a33fc01d7c42d9151f8cbe30e54f43957f895cf55c4f7d1cece263af58e5a76e4f4b89c7f15133b8dde960ba5b45d5d049386041a8fd31d321655813d09dc389ea72248b99e273d0bdab3e83bc04a71883546b86a25fdd12ea5346d2ba7577a438a1d2cbce202382e2eda65a783a9fdf374714de202fbd66ec736147e481748c9512ed91642558574d503cc40c42fd5207f4f1f50d958f05bcecf92bba7698317749f95507ccce1d4d5558907dbcab2c03ee7330fb89e0083935d0a5ca2872f383ed211c6e9c12919580edd15ae1c5213995cf0cc53242f61632f023021106ac8e683b485950e2b4e8d3a5a4c20f7af6558db7404273659bbdcd17059cbb54ba8751f2fd6138698ae8f78f6b96ecf82a833dfa29ba2ca1110809bf9dd948b294e764da465d441773c9bbbf99bd37512df4b208608a25e97dda2ebe58139d93b7
+g: 92000ea70ab4041fe58717a88d93ee93fecb90fef03740de69b2bf4b320f2ff405b79b1c0d588fff1669b616b728c55711dbe484f4403784b8f8a193af4db2befbbcba0818459e6fb7f022bc233a8ddbf1f885d030d385218a3a1d670b5f52cc7afda10d74b718b3a73d3d3de129bad7647daf2b72bad3f683e4ac57c75cc25f779d615a8562564705ff03cb188119c4779e4eb3a46c9a50543fe5170084a53a659b02c7ae65397353dc34e271d345ab3fff2d3ae8a018f95a51919b0510ead4cf28c55e8c629aadba454a5363ac5f82d49da2cb0a091c5c58d24ed86da571d1f815a83036b7510046f83bad20a49382b4ba016b4742146a284e173d07f8042f911bc2e5d910e5b15b09802856809b1e0908064e794acd0f66698b97e956fe8eb874af8bb96e70eaed6388e27b9c9897fece0bf4db80d6838bc4be2e3882ff45e66e9836fa647cafa1249b81bedef8fb94fb38d78bc8cce70b00ce087c8c5dee5d1d35ebe4ba56a933b548483b9d56e83e68f55f9ba3f7fb026a442547e15116
+h: 100
+m: a9354c66dce761985ca6ba3c7e161ea4c01b8edfd94950a7cd7f9360e05935446dc2cdfadb43659879f4fc05173abc895cbb0c24fc01f1bd659745fd37384b2fb75d76f9879d741e25d6e4cbf178c7c9ced99f4ce8e66702b2242a8de1d96de0d4fa5bab2a87cd901c910a59c706872288ae1988eaf21e7db14c6cf3cdcefe45b8fa2df167b50ca7baa7a1fe107d8518f7add1c5683eccb8ccdbddf5ff5ed99131f5ce68313d53
+p: b5fad4366a5725718b918c6612afb4964f80eb3126e868c4f37a841295b2fa4c3f7726f87f6094f55a47155d7b1d6fdbc85a20bc8fa6fef9a2563a35d1bfd144138968b472efd48e072e3160626b66597f2e05688a4cfc04f44d0b594a528ba9f5791ffeb3adeb791189db358eef8b7b521f69a9f4497cd4cedceb1d45eeee308f8bb2ed3b8ca4a3e90d8ad62cbb4ee84e2e5b0f14c262f5bc93a559feacaf6e9106929acbbd86241d45438c556f5d607ff753eb8592c94e514ddd17a84ac9f40869c05cd0a2f1e6e3eb367f1c492ce9a5e4cd4ae55345640580ce0fc05bffb8e963168de905479412d6c1eda8ac81f71f6eb9511e2b90003144d5793af2137fda67d6e8487a797450a6c149c82d9a4830c176e264649d58fa7ca3b3605040d302c5db56d4bb58f452821934bd7ce689491c86bbd61088d7da967e07f13a657748998a67fc06845940498411b494babbfd9b6b6407520082666b92f876917c407ded2528db098bd98a8f4fe56bdd2bfda2d32f699d01933b90c16965d6b1e059
+q: d2ce16aebd336e053f4a481b29fd561b965c393d9f8236d7ee9f984f73cb9a8d
+r: c54cecac1a88615f90097266a876532209ec4d6080f256cb49d87a2a5ffbb8d2
+s: 579e099e9277fb696ae585ff22b0885c4c866696eefaa7fe1866fae338e2a0a7
+x: 63eaf858c516680439dc271cf65cbe7c931960704effe05a2e03d8d4996231e0
+y: 95a5f0e09cc67d063e8786f2d9f79a5fc09072d5a29137327e6c33d1f256d3ca1a79d035b7fac3f410b234df0d44700fc723d03523747b6ba0c6a790ca880bc7caa921a8d4edcf4f2004cccf80311d75dd0f0cc701819d1636423969b4d2ccb3f4106cb2ad132c55ce4f2f230b060c955466621b414dcf0f7a6b0cb40dff6b9239b87781fe67c48d422d481f13f1f875e98702bc4e97a45e34caf4a4e24a1b51b97cc73b23d0f5e20ea6d25398c52cf513d0cca9f2cfd68c492f91e8bf9611e49aa48ff79f5f566e3698b46814af329944112dfc2a8fea3c51471d93184366e8a0a192bed3ad7d5e574524f1ddc3dd749458f98065bbf354fcf8912e81fd45ac2d791d17ab9e60ed2536039e2cc00edbec444ccd7bc94f7b2251784387d88e6ba6ee1c840129772385a4a12e540f58463b87507aa44d9aa1c6cf0439cc90c32f0aa0d10c493653de7d123bfd3e7a0aea7b47fd5f62838ebdf6e7a733971337da2dbb5a96c72ee3882c88eed74e2d613eb84d7aefb414f6b0d51ad70a1bdc614c
+g: 94c5e4141aa62747576d8f77dfda28549b1d32b2385c3ef674aa0704fac7d7467bb66f0c1013782268993fec56c75ae1bcdb398f602dafce94bfc7a5a9b4ea6cb78e7a6bbfa7d9c735d709daa60389d4023ad5554863ae3c034071652a029b188c9ff605a0dcf00f82b63b90dc8af111bf92555415db91dce5752f03cb36f7926ba358c99c9a32612bec0712da6050eb7a27e7dd2d50f4ec9d0b12a64668525ad8214500cc88ec10d4a5d68a7440408edfc1732c0d6fa7c107d1f5bb259f3598f562b45b780e6a3389e9a173902994ad8c5b1641b2fa30d5a1a1c53f3b82ca2786ff21f63148093a8717ff879e580d963ebb5020b6a160c9731c3387108d3bbee2a3925dc3dd9ae0fa97c3e51bca20666c0e2dfd48901298bd46c11f9f9854cb599814a9ee5865653ebd29650d9aadc1469a222bea446aef443317e13681bffe506c023e474ab0910d6bf25a75d050878d6ba1f49814fe848619eae7583a54567c3f6ba0309783d48b4d653bb45b74e28389bfa36d563efaae36a67e18117bbe
+h: 180
+m: 4e7ae07569250b
+p: c91120e215cf1263c2ca59975fcea94f1e118b6de0abc8c988f706b277900bb42cb2d96c9bb6a9519d25f5529e20d5b360a0acde1fdcc3b33ce2492d3661c3aab81cee079dd40bdbfa0dfcf867019cd1e03ef01f51850ea19de0f667c37ea7f9cba2f6c68598a11645eb3d34a7e6a52a36b6161a375ef3b21d3cc82ab44e45e9c76511b52a9c8f97ea435a9abb8e459799cb3371f3ca7b58faa1e1668f0cc1289d63d567faff48c569e252c200b978259e06d9b8b37f9d2b21cd606c8fe48778d11044c1831c80fa678e8f608e179b3456a78b678a047b74a03ffaa171c1c165d3e9436fdfde14e505b0967e5c18974354d9b86bd81e40f571c603801fb78bffa52a86a3fa5a09d80ad19d4d9c87be1d3348a8f6ddd1b1920cc84f2b46749d21693738a6e80abc6a5cd16eda93738ef3bf57c45612765b6392b12d78685e6b4a893ff0f27ed6528d8cecec92acae2a930e4ad04b5c48e1c70948aaedc1bdcc7c2afc58d0016d7515c746a0c502573958aa1812b3161d54e3db4fdd6960faa465
+q: ae4783fe9115a7aa65f1533d8411425eae2898f9c970f6721f52bb59c2ef6827
+r: 222f31f6086a4a81af34dc37a373c2b603493c76996a129d49502f64cac4bf25
+s: 968de9546a45c6c633fb23db37ec2290755fb97a2bcce21bd19a9d7bff744488
+x: 67749c7c078a2d33b5d62d9be1c4544e265a8a33097b5db480a4508fd0d5dbe1
+y: 3359b5d22ede90ca85f596419f6e75cf4f3f1a0bd80d8f65cd7721c0e2866c9ca39067d737ffbdbe9c6cd827548710aa1807321aa6a65a600b23cb5ff25b86dd8550421ad20b2602ab036264f97be5ed88c9a0a1c7755bb41ed0e7472306392806e51d8b2ba50d335a01921c38ddecaca7af7c2f3f4e44a9a83dbca4eb81495026f2ac11322e07cab76ca67f880de83c2e9f5e628e275f7b40e114034e36efa6af3461f24227d0de0e2d9fdc709aea990f274fb8823ba3dfb18a3fd3d37892c65b1df9b85834391c35a484927a02bef25c483af48cacd6addb303957816772c764dc649b8202a81a8450c8ad50a68c748a01c9884fcb47fd51f497367ea7ab28eedfa171ff11b3c65a9292bfcd1d4904f3b25fef4ce75343f16eb764ce83b7fede384c3e4828bd71f905bcf4f45660bef76abdff80d649c2117728d098272fe9c965546563ae0089f5a1d49cd28adb2812049b44d521ce697294cf6a7a30d197e172d410110bda15bf5d204486c72d51ff97af4311ebe1f83af2370700ba7fb3
+g: 40316306b4a213e51f1e2dde8724751c3fa1555ef68f900a0f3fdd4586a93b94652ff55023262aa204770ebac035cb9a10f22ea9d1f2fdaf8bf4149e17bb74b8c9861761b77c5e51519169d62a8cdea3adbc41df8b5fb18b7b46364cb85019d4996fac5325ad25d0a38859c88339dd4d23a3b992ee436ebc886670aba858e83c18e75264e77bdfdc8f10e8aa21e738cccf23984526e3de20ccbb2521a756e3ab94a9c795182df8daded27b060cfff738f6b356e9f7a7a297bc5a1d984b26451d3bf0e09469eac2bd8c8b37dc64c749b0bd26e1383c7ba5001f2abb2ecf0961b26cfc6191ef987adc6d3ae0812ebf255ae82b8872de45374f475d05c620f39575441b1d73071f0dacdbce5b9894d31f3561a6c0813c7994a2b98c61da75d3d946b23f47962cc79927cf47443a3ce61305437813c6749e8abd9e2a97d39a58b4b50cd9227dbeac3b11ca0764c0b8e34fe0cb2783d10106839930a13c05db4a7438d63be894ef6345f70ea1adbf46ee65c25f0ae858f7692b949183737034a45a30
+h: 180
+m: 0d013565871e6a07b5ea23dae74b7ef8af4835c080914022653911
+p: 8a0b6e292cfe764c78a9449ff2b88778f41c09d777de23ddd13adf162d3d84e48b400c4487f1ca82e4e51e401a4d22fae911bd943bf216f59f00aaf8e94e87eeb5bc2a73333fd8bd49e0da0b3a19e0cc8bc5239c07f89168c8b8363c7cba2a8a090155682e788236009ada70d5d8285edd9a467df5bb014931dc6fa405c9b3332a666bcfebc395a082c113e75dcf5e28ad523d6b12709acfed7e62036a3f8d0fa6c433ee563745a900888f68631df2a362561b3140be33ad256c297162c1d6f28141a479e52bcc0fdaf0f53db9c7a1d013d6d0b7f0c6f02cbf977a2f2afbbf90ee3e65e199704e2d71498e0546346e77946d6bcdea28c5a3275069a18f1ec8d0785c3939831aa212503f9fa5d4d8f065c7b41b94bb13c6e2e1e75930148ce22b029b620c976e1f38b1ef6da08b3c1f2ab37f6f96f86494512f268c39bb33e68a049d19c9a0ba93b4dae8b270e13a99f5bdfa93321580074b422adcf95bfc648d14d7f55bfb341acd0d0f3f36ef5fdc7e5c3b499ef365a4ac6de80e43147b40b9
+q: c55a6e8de86e0208693baa4cc38ae83c7d004a12a1a0b87e83ab430f4e29e2db
+r: b949252f11cc02c38a3fc1218930db9ad7a24097fa8e9b42b44f1d09ea9f5220
+s: 6d22c65f65ed864a1f232501100c99a331760c14566670784ebfc5bff3053955
+x: e243660b0cbff5d84422bbbfabed9dcbd2e6970a999997890be51c01a4c128
+y: 4f8096c18bc3ed8971b3514305200348a12d95c05e1487ebd7fca567adf70f0237fc19117363b051ee0e80f5e63f8fe0d90613c88750bb032e97c9487a00210b31106da93937807258411660a580eb2ff2c01ebf4c7ff36c5f70bdfecb2570e55ea6b8f6d9dd1c7ea752f1b492759a9eeabe8e3fe9385467f6820b5d0ac93dceb1e634dc1ab7621492c9b6f23a0258dcb44c0158de736b50a9e5034f3c984364da9a2abd451598ab5818de60aaed6fa7eb102e1f2c2623f8af70fa3559bf67933bf59137ba259af1ec00ed4b8d8f354a8b4fb048e7942db7a53f4830f456804cfc77caaf071ce727f4f61d540116f97cd06d1fc1d6cc222faa0310afce507fbcd963264efed234d70ed4198e7493e67ac2388fd0e969c0309131326b506fb75caa58584bb5533502a41c0516cb63a086124d5df1b530b5de36e1cc6f0f9386b9dc1597ea00601e2a3cc3457d1ac3b7d4e593d7575ae69cd0a664a8ae1c2f3ee128abe12ade38083917c77d6427fb3cf8fc2bf1d16e562f440f65d26a229f7ad2
+g: 819ed31af9b43aade213a15f57f9c2a23693b6cdfedd17b1fbda475ebcc5666c8473645d62fb3a1d67b6966ca4a85588dc31c278e5898b76b27e48467161c9ef25615a1d5e1308af93af4fd4c9b6698adf65b587ee162ffe669f56d4fa511b896c2c91afe619259920ce02ab157599826723e259fcc1b158a053fac35bf2e8a899634e2d345aaa8dd268605ce8c9fa8de22355abb9d6c197999d67b31317d9f57fdce6e2ae77ffec26db0516ab2c5d8af752fa912b7c5e6631a8abdf0191871e5ef1035812c5ac3cf1e83c45ce9a57269eba8cff000cdd466ea95d50b0531eeb30684c7030b1d230fc3b53b1551095d305df5ddf65034a6052e4c7096b2f87968755c8da2a270901886139506c3165bc56cc070263d79becc30e27bd1f47250cd1463aa011af79309a8c007441f6292b6788f372510740c9da9631a0fefc393a2a1bc45f28b239eae4c82b97c1d785705bda235a2d95cdd28af794c411eee1f95d0fce855c00ec21139b45362fd69388267614458ee32ed0126dd427d42e23c5
+h: e0
+m: 5544165755e744ff748e3277d1017ce1f92996010a3e4c48b772041fcfe2ea5b70ef8c997df7a27c404babcf9c5bbdfe052caca08cbaa6f62d1a5fb7e1cf45faedc948ef620303daa8a534327851c6f6a17438fbbcd30fa22faaab7787d2fa4a3f2e7303ef96fb68c9fe685893d3ab32ab37eb9eee19a29e85cae582bbad1dfc50b98e4b2adfee9b3516062ecf9c2d07041370502486eeaaaccb7b50c0ef4420ba7b707a
+p: e068fd7533926bf7df46106569173bb5a42aee40a5c996ad9b01ab529639b55c28e4dcf4fb9c0edb81335002a4e4111b1347f5fdb55def3077d459ac5317b60731eb56f97c035bd162af260910f37bec47437ecdaeb845dd185b91cb46b5c4022865ea31ebbe8b3272b762c1895881ac487e5c5d9ab90b6282059a1e981ea3f4097c4b8a8e8d17f26d73c1fcb779c9f67ad4aa75238b65d3d736a420e40a3309fd509a5fb47574ec667f663894cda29e9c50c5c4efc0d94e5f3a952ba874cc62da4a43223b54a3ccd253798e437340de9335b92741b73210d0dd3a2b41d15a41dc9b06c931340f7eae5b232832d9b7b4c67151ad8abe3869182784997c3f421cec561da7fe4de6e1debd0ccd12ad8ae1d03c580aea0e2b1b1a77f5f5572523a9c4afd99ff1b1ff6866677fe0187c5493c206c4d89fba7196bc68889cc71542940adf707fd91589cfbc207ea8a32e8e6caec2f761fd6712056a69aa2d454d2fc814844a85a3c6e43074a1ffd294c0fcfeae0ce48bdcf6794bb949fd0740ef7e63
+q: 9613456933bbc547883efa93dc8c50b3528e31bee6ad0832f0aaf81393890203
+r: 84084f214704c50fb35041dd1632546382496b1093d644544b781175e88c565
+s: 7bde6c2d6f6d81946ffbc8d3121087683891fe829adb6743066ad236a633bbc2
+x: 5f76f382983be91fa3cd87e20ea4f2a64ea5fd3a8b7e336321d3ab028c99a1dd
+y: e72024d9babfdbb885f4c2e656c67a8c07749814476fe432db1c808576362b1fbc70bca3d3098f1c347c28882031a5b80a54096652e65f43eb9a9b1169c4af54a5671281c95572da0609d67648b752c9cb57cd7f10a40279b39af7480e596e4c425c12f5ecf8e33c0f7c1106dbc58f9bf8a3c8e81901c9ff97bffa5f6a3fc6940b0d468d160b973586bf1a107baf29adc132b9e7bf5c9f2bdc3d3cb5254bdcb09169bbc03d0a94f6bec6c9b2b6b881ad9354ca1cd6d235e11801396953e3fe21ce41a6c03ed4000484ed17e9f367df50bb65e31d03f77008e403ce27db5f3934abf69c9d8d34b74e473c81cfb50c881dc9762b0a87160885829b50694a87d398f0be11d1b44d75fdb7d2919a4f7f26cba7928ca5fd2607cf453ec7e2edae117dec51dc948045f992a899aaabfbf80d0b3dce08e63b16a136ba0928f087ec42b75cb57114b1970491071ce30c8119a6ea7855df1b23d005f98ff175b5d54b950d694df17878d8ee676d4acaea7b0869332c8790fca1cb9cf7766eb65c27dd0aa
+g: 53d837de9316555dfa4f027dd2a56b4527ba164b94fce67689c554144dadc559b14c372356cbbc5f01d356a64a2da4138d04bed902d71220a131bdcd7c2c867ceca64c87e662f8f841f6a5040850dc4fcef2baca890728e762af6e81eb119e173a2a92bb7e2f467d669cf0522011bfd0afa25472c20241bc23bf0c7e9a7590e494aa7e1fe08dc616150b9f8202ce70b7b7c1e13bac8dbfca147f8d90765a21ecb9f141d9f70862f40af3c8edfc0afcfd3c3810c97e62ac4b4e99b0de795ee56f75749d4a4d1dc6afd23b1fbfd7528df5afd04155cc21c4b54a5386e3a98703601e1a9ed7c0c6fe8af8d54bb5cf9777e38af474266b179004d750344c8eaf0be6a1490290a26f4a9d1a144fd7841ed131d080b85446a35b3d93b4b0f092314818682a9f21ac15eaf65e7106620dd8038497a7e2f3df9b01c5b835e55ac4336a57adbef25251f95c487812b877a5453df587e58cf7f59e815e5e622b1e38fb808256547304b63e9548b5f03e8be4650203d64b68ae901a06c8d9c809147eaac90c
+h: 100
+m: 3a2c384980d3903dedfeb912cb73b0739652cf428805630143e3d5d8d093961ac6dde83a3ef46445fae7908028d3e16d0a4c0a449e016303511372e07a7451f0785e231fefbfd57797010f931a912425d13651cfc3da031705f61c4f11007ab2914c6eb30944e276801622c35d0570cb9162fbc65d12d6bf7257080192b04a54abe8412a3688c42a4cff79fff3e2532b12a6907b2b41521256918d05a8cfa28550cfce159ff8ded87be56204cfa39262db6c5aa6e30f13
+p: a635c59a578456f0dc86a56b4bba959acc84476b72b5be1bb7814da6ef36396152078e6703db6af604fdb82468367838a26b2c9f9a8accfa8a8741b4166af0122382ac3bd474a8c62fce402af6898bc6c247559cbac578ff1e8caa1c96cb78804b182540f5973e4a6c6431dce82c7e6dd0390395b148ebbbe9b37dc1178c5eb8b4f10e17de4985714a23086dfee81c6424f88f24af94306f44561afa96c50e25505f942ad5ece4734d6b09cfdd4eec18e347800adaf839a87959a380e0b9b13f45ea598aa3684c813ce318729ccaa13257723b8c95565489d6f86af12c5153ab5272a98c42d6643b67a31ce64e1c358874f7793584ca059290a5d8af8aec5e480b730bb29e8750161edf88ad463baad3287327528cef517abe7e023a18a11d986aa0cd112a68fed6a4ca4ec3fb9b72461f101fa35132ac9300058bc136b7fcbf30831825e86977b81757da26b232ef4890ffd94297cef5f794e3129716226d804e23bdecdd0a9f878442c5bd38bdf97ac8b1e391845ec230732db657fd41f4f9
+q: ae55f5cf13dceb13dd19cb6043b004e61d28cce9eb4b0d385ba5de3c3b18470f
+r: 7191370e8a88cae5f03903829eb53867fb52dce11de751fde0d77e5f803230e7
+s: 18e066762501f9e77d08b8ee6a182560f1e42202193739871a4680752f6da3b2
+x: 914a809b0742631a6fc2f088abe6fe4d411e901f6c439dc3d174ffb6e71269dc
+y: 4324dd5fc8ffb6087d4025b71d829548511598ba004fd0de676b322f7b612d1fbb1c48d5c392aeedfa54ea27d838d0d4ddc9a26ca48a5ad00c7fb21ecd5d61f7fa545c69b7224904929bedb71aa8adb13f05070a01f45b0d20bea9a425edace730aef05c51b6f3ffa029d44eec79d9e7fd30f15b9961fc7ad94355791a9c3c6bc0f31098f367b1eec256b094a567f2861c6a5049cf3bd6d7c9a8d81022f93273edfd660b53b5789410997327f5c1ceefb8e1cb8159c34026fbb38953b10e8ff9458cc79b2111e44d510b230b8251a6b3e0514b74815ee7fce3e24f6f1b28177f9e552b0b1a99e74ff936292021051cf441b23245493e0117f045d87dd697ff75adf1d75de3cc4853e1ae487d436062d533b157a6c1829c104e2f6ce6b045b6c1d1f4d83710b611da9411156934c896b55168c28d6ac80c943a397e5c2745ac32feaadce6b93fe1c3121146bd1dd7604897eaf41e8a2619816e37f2e22b520b00b6fd9a24420f47443fa5f14b0d620fd3920e6eb64a15b95d15851abc8b63b811
+g: fcc8fc2cf59a7693585f1c39a01051ccca7d435842af80f0b0808142774473b8bee527a5ff3f858543deb2af4715388e319d9a36257d8496564fe749745b44f62939c358a6724d62b36bf0be8e5e264b0ed0c06e36a37a4af8908214c4983210b5421587601b04c7ef51291d4cdf4e939dc4b37b575712de8ded5be001bff2027bee49067c0e8247661130e34661c934d919709c6d7521c203a43fe4362ec0c479fa54279435206387450f655353b8139129ccd83da1b6b61279017b39e4c1b1a8db59f7facb682a4e6d642cff38a5477ff6be559aae9652523f12eb057f0519f958d501a62c3f8aefb7eb69cdf68cb217b5fbd5fe32e1e006240a2ad953ef454a234fb41ac75f7d7974620beeca05b3e51b901d2a6281f6a90c4ac4c60647bad3ac2152e813cd4b0f830ca36adbf65dca3483b95d7f05630838f99de52301649424b449ea05efcdf2aede13206f95a1290b2fd61907655d9025d0fa0b46d66d49e92aa09d8887abcda6d68a4c44e53b3fba72f81732a8fa7b3a589b3ee4790a
+h: 100
+m: 
+p: fee8d17b45d621340a534a162c58fcc0f397d4baa515ae56acc00c0d09211511e63e40c1e26fece6aa85dbe5ad57721c78801087668609dd3d2eb8de079d860eeb6d6064e0b536a609cc4d951374f1df5c1d98d934d2de51dc818ab1d8f19f8c97fcdb63cdee3878c25bed6f51a658458bf4024f8c26d234eecb3c3254328f1b5fb6419613ee530a4dade1e99f98f15028c837c1a19d30e367308145ccc71e54c35060d02f5c11605782ffcfaa0f210b7d1998defa6b448ba76401e827e50c7edd3433d5f95212b61ac75fc77461977b87368688bcfcc2889fe1c033fdd682858d8b34a64d04a138c30adb6dfe5387281eda06429604178d8d8c661342f35ea77e08716687503b2525c5ff390513d56093f5543be751e0d2de7ca9aaeb694adcfbff52d6a87f8d79bab579df3ec9b4dc51fd0312bf63ef4756c4b093214c5a64a4067a018685472cb37e81334ff9530dcd628a44ecde999f8f4e99408978d3b52839a04ce9110c6c3c11d5c2d79a38e00caea2a74aba044293cdae470c348f6b
+q: db744f628d60ef586c449d07f004b05df98ed06774cac1ede88f8c9609b34c67
+r: 27e44e643e960065b0f65c260987aaa22c91e92ac2c9f33db998d5f22bee7a2f
+s: 56801987b9b68bb3ce55b3e0a62b4fda25589f2e69e609fcf6abd9c28355f79b
+x: 3c38768ab71d691e0c26326ccab8b89cfdad211d0a7fde425b1993efaa64cb55
+y: 3e3429567c42211b12193c53e926ada2b4521b4dd02992e5c4702065d5ae6b14f2a7c9b9554f96ba3e7001dad6a9e5aa2ceb90597a57d40cd67d09af9e482e9465bb614d0fb7d49d1e3095414caa7ad67101badf5bbecbbe20935ba242759919a4c5bd8fdae8c724a839019fb6acb58ee6ee6493cdd38690ead6f0a59c442bb387f08f62f7ddf70b64554f83541aa888dd78b5759a00b0380a2200cb6c95bbe4b43d44186f0beb6e98aef8db4a53164e83fa022ba1fbdd4ca6007c34a0b5ddf24d04e0d321b7be6731f8c4c28c18e56362b30f70a3a916e41b48be47005acdaa6d8d546f6bed9c554ad76bc9f1b517afa8d31ca4d2029aaafb795cf9e8dbe7322556e678e90c09b41e4a8c1533c1c4e568bb2478ec7b248beed68281179f9f0a60bf0f4868b63fc371ad666e6738bcb9dec5b82026171833d2d6842bce9e5214e436e2d8316e65a0ad24a30e38aafa1de7afcacbe0dec155cbe64d612218d22ce2a2633671714f7d1d7f0d715650e6a663d6595b0156ccdca935d93132b6bff
+g: 212235e323636f061874040e52cf5c500b80e27c4dcf90784807114f7045cffbc83b425a5a31f11b30c56fa602109893e074af52f1236468aa0430e953009069ebbb48ede64365a8d4cae6b2857084a6e7fb59541e39bb39ecdb0bb1e9ad02ec4d89ff999e78eaa4f1bda133a730346c5e4676d7e16346ccb7b607c63ab3b9f320ad00e0b0f0faf6e6d75f1f441fcb038c546a329e13d1b68d5cae27c6359ac607112857c4ea367095b7de4ab39501c0900a9dd00e8cb64ab20d193465efa8cd5eb641128fe8daa83e29880c7cf504b07b14ad80aa9e044ed28a38d990bd2f18b4042da4c97528bf02a1fdd9086e44dfdb179651ab49bd0a6e68cafdb2be1af7f0de5de23e2049bcff30d9928ca70eb0896f5dc0b6192b9841f76029f1c56bbea86c0c213c7f7dbf7d42f795d2256715158e2c4054e5075ba908fcff6fd92ee5570765303e1931bdd878146bda1c34dacac43a2a357437947cdfcccdc2bbcce5337d5b4fa483b6c01ac9b389886b99efbeaf145979626fcfcbe5b4a6d9326d13
+h: e0
+m: cba4fd1d7a0d57561b27022803560168562f6997bcb1ae596496e79916ac13dcd044bb78e6f9e9f0f0b24c4fe30acd7ba3a78e29428d3baf5fe2ee569c9aea5e34e0169bbb2a274308ac78e06048bfede129497c1926edc90e55783d5fe4f0c11087ea64bb6225a5570fecb13acb75c47e0593e9c1e1cbe36ebe6b444791976349139b7f2c912c311748a742b6eca7edb400e5b3f8bef1ab31313303e9cf14
+p: c0753b107ed449541d42eab7ae1e1550b4e87750ba7a45ee6e6a00764633dd34028c2619930a25e764be4a8dfc5f485ef52d9dee840a5e4767f4e3606e8437e310d08c76e28877fa9cc548097903d04a0b165b2d27bdc9b4cc9db0d179733ce45bee7b6497c9eaf6a56fb95431f4248570ed3d278eabc85c058193a39bf9800fa6a881aecdaea45b32070153062e4166c6bb34e44499f1054b72c928f2f91edde4a908fa75b501f3647d71df17b4aeb8668dc4bddb1cf25a52ed2611fc3b0f2cf0c96effe48e5de4dda75b62d5fd772ceeb52913d70af52a625c341169e2600472cc46f6c336e3c02885b96f46b4e77ee8b4f5c16df35109bf120531cb70157d820a36945c63028602ae5434dafac2e8374ff0832a65e185faeaa516705eaa0c93db88ec3712c627d7de880cf91a25776af02eefe1f331715ed66531186f14df58b58578af5e44a5b1065ba1e39d801afe4c373678b4bd7114f981c5159bb1e22474eb43386565d4014e155b310f3f09c3f8ce31557a2307af2c3917dbf8b457
+q: eadeb843ff31d95daae4a01d376742120a1bd1c4f0c27639ba9d9de1ae9fb615
+r: 148ebc9c6f1e88b32f11c207026d7cc2e84a838a75b0b906a816c332d55a574b
+s: adbfbf68c9bfcd93813bc0452102ac6074b5c18a90d33bef438290d332b3c847
+x: 65394f78cf7ef53ab7cef2277456d177f194b3468c61a2300fc92508369e1174
+y: 3e440d6f5a06aa3eea13f9f27013f58b60a7d11cfede48c212f5f626ee33650556ac47946e6778d5b6c826c062ee48da167d08e835da58d085849b77ffe732bc91f0926a7fbe0fd02c76c6c539304b36019563e41a049b7165a43e73cba7b9e536755fd35bd85ce18a51206d72d75d485c2915aa7ad9c3aefe7892693e3e2ab2969f6cb31ba11b1726e8fa4f00b3b35254c2a2d4848f4b7ed1e52b0aa786016404346e4a764b9c56a261f5f9321a9e87d1a9b5221b44917002ed222f596ce56e9163598fa3baef48e7556f6c78a5c6f31979d90de4b12be3e23225c6478695768246dbcc12b9ad3dc7aea89878ed5938195d3c87179b0da01dc99786527ebee362c56d5622ec8c129d43878bfc226f3034dcfe5415ad1a01de156bd2fc1ace834e25ef7f4ae4a02bf4bb168eaa8ce8fd0fa555c5a93bfc17c038e2592359b4522ce15b03dc9bb0c460e714ef07db4e328ff82a2bc6bf52c0b7897eb1e1182452b008f459dcd8e3fffe716ff91653c33f5d7fc8e470ec6f079e94088d4186a612
+g: 37937d8c7b7ff9b5e80b1bd910cf886325e697c029fac389d883d3559852d8c925a92b006b6e2e834847ef9b9b9f5e577e9731ca4b137cb51710fc52e1200fe24a2f25e9cb50f54bc1e7da264d44480b8064145c70f94e4e00958b3cb66e5ccf30e4fc10073a5e5bf19d43a39f911d78bbd43be6e854dac0fba93adb7e6f0e2fc65d938062fd0db42472e0fd013b361f6f3694c26c876f0e11e291299af026fc964336ce4e4e1708ae928f3312f8353f11df0c258ad605b1e084212ed7d58380f48a7595c490c722879661dcacd15439034382a158adbee93bafbc2584e2ffe9b8d55d92efbd3444e751e51a2cda5260d14141a2c5cfcc15e21739cf730dcd6b850fb523dc82a318b961a4f4e6d5c14f7e0a17417e5ab3e8c3b33fc1ff43d0695b4abeafd3d7f6bf03f7a9f4ba291464dcaa88e5e418c0102cdb17bcb03aa93aeb5d9ed231d12e99f27e5a6f0ad3fee43f2bb034aeeb4421ac22d2dbf3a5e93843cf9770d9a15e17c2b00fc2ef2891d2173b149137601efa0bc85a477fd2885c
+h: 180
+m: b4dda139569a44b5a179c2e5457bee1c65b0894c8bd3f3e336cfd61f22842a0b33228bc953ad110d9f471398802be2ad509993c6
+p: d1975e9d4fea417fe2415982f42e9fc5827fdc851bca21f5fb890414e70fd082745433c713bc925548e8fae09f7d4c02330aa572ccac10bc60e7dfca034f3a1bb6a257de6d21ced88fb804fe2e6c98f62c407c893c56f7b87d2ee7e7438684b115f1d35f887249b0ab922b20a454e9410afe74fdb696b53a57eb038c341d5a1ea72e7a9e7b8d7ffa633981da6f86517c3a9498dc4d1e73df8a86c3647f7028a65a44230297465c563da84e5cb22ca990d1f52a0232eb948a9b9f98d27434e4e1559f377e0f2f33640eeeaf9f8276e729585f93fe749f7563b87e00a9725e75cfbda5c48651a09af950b2a67c0f481708baf71d1e2d61250df8b2e11a8b0d7892a93a91ac47022feeb641a0401256831a810d699f187ff2a9c564e28fff200b25d56e9d65bcca39a4957b67c1050b74c1c38a34800acab0007bd508aaec5496290cdf313b3b15e258ba0e852cf08e11bfa88f38d297c2b5001dd6807ef81d77a796af530fd9e8ecadd3b24d356bff4f20d81cdffc7f2e7b615416c3923ce1b85d
+q: aac8b1f5a8f8f55410f312d6d2441b33c806e948be692f008ba7c21f4ff1e59b
+r: 2b7e93a7e1123cb62bbede1c006d605ca4cb326482ed5610eefc3c09c018c799
+s: 224237bfb5aa7a899c010bdc9bd3c995579785dd71dec357279b68ed9cf25fc7
+x: 2367d7a1e5bb1090299898f1a93afbc7685fb9c9c6b6427c881b1f972be8e8a8
+y: 5638ec10d489552fab7db5ab3e3632c1b474f2e34fe51e44de75c24320f7b88ea9f55a661a742005e2ccde5f274f4f5acfc68a45c1fdae90931ac7598b63fd3a222ba622f3e5d4143cfbcca3e764cdb3b52da099b66f414abef8516c3a7dfc440746c98102e1a31cbd8899e3aaa37b4b36ca42495468232d52441e0bf9d4f9531e985e116ea96bd1e0d05f80bb4604e8fea11544eb97e3f04f0c4b60cf0b7388310c1012a4db38e33045b7aff192ad25d2848ca7b787fc2e7059c6ae788095f2a186821de66ac1fe39827d6cfd4d2789198465570683f19099e3e1f3bf7096da9ac000a09ee739d299b418946b25f634d1ba6b53bc7761fe7587b02feff561ee481661d010b3d9e87998ca843a77c0459aec5d3768d462d5a499ffd98ebcfc7c112c417c7b64c22731467d56a5e7a7661b40fa5c954655121822b4b1fa3febc10e413e19c0599fd744a56254b7754d433555a49b8fffb5b80717c0b5049f0afb1c842e70a4e82bc8dae38017e3f456c5eb4b0820de0778468cbeaa782515abe6
+g: 938a31e11b17fc5272ed65f5403b595e025137b510daec1038fd679f2e1c120244fb8007ca83f5d43af98cd88598e08e761e622febf417c452445da1ce0cf56442ac45ca500775b4f3c0cfbebacd9233f346c7477d86ee6f6ebe6fdc923b1e707a1b3a59e1c8e0c07dd36710012e79b93ddc219dc7f58aa4bd525e8853fca761a234e4badb5d8f001c119d5c5addb2cbdd4b0f89747faa6a5c1ea601eef695eb014ec7bbcc5ec71f8779ab5c31c1b7b0d381fac3699d7d38f7353f5e1188ab837cfdea4733242ec8fc86e372a2029818979caecd1f5d8d0798490ceb92199283a426d77e53e0c8ff4ce66d4a571b93186ea11a18f9d1db9143d057ce1d31effc82a84f706ed6b5563e8b55e41aba68f895fe743123f8e0b0fb7b2100957e25ad4974c4e03b6241dc2dc64166e507185cd01b7dade03d9452bbf9c58888fa3d3665f08f1e98538c6c2b648edeb1501e143eae11e2e0dfc164df0203eaab408cffa7b68c7f3dbd50716348afc688ade5673a1e30f7053484a1429b7349789a0336
+h: 200
+m: a6e57e358ee95fd5d1dd95650b1f20b6c0ac4b83ef07f213a7de4bb79aab5faebec0a609979a8d84f5c039ee08ce65f17b61ed5397fec71f440c2ee689b474425b94e695c90253e0810574a39991b664eb6390090882e372714842477de0d56fd333039a1a223549487c2c6e36662c2631ab0c80f2a79d0672
+p: bbed6cc8f36354c59cbb3e073d68cb53304f7249326a3620012fd3bc32b416ae5d64f5e50e855df4de20536ab04175c30bc62ad07836365ac5c526c7945c9d52672cdca2750ba6d23173afaab5333f7d33120d836d843466ba0b529a43a010c4a3ebb10ff3d0d0e92635a7d94238689ab014aee50ecb8f5cc363da56f8f7d34a234cbec4ec7757245a982d2f2c09ec261bd45d511c500453579aad2efbef88aa0ba371aec852ae7cb766692416b25447beb97d8db8cca769bbe28d1adefe07be66b9b75d8aeba471cb6c32765f6e39425b273460fcbfe3f49f05dc64e9d7a69c28bc70525e8d5acf32096e693c41899b6234a333804551c278080185495a2372dee0995c583c762e131fb8f544a21846d04a260d0f2fcad9c85dbd30b48e32032bbbe11cb34c642163532c466953e4864d8768c2e8c2ee31144d0a9e69cba4b3d98ba5ef53682462786fe8a5bc43225a3342b87813c41e8a08dd65f896885f00928854bb0e068b805a71620c3d9c854dae4c8fb441760c628432e921b67dcb43
+q: a39300e431619be4b8c2aaab03ae649a81c1bb8554f3c4c2c9200ba7194fd19d
+r: 2cc389248e2c4bd59c57770a43f469c9eae30eb6c4744ec388de95712d58b5ca
+s: 1bb7aac3abff58f138f9668f112c687d34f31c618992bceec68d022fdd9a3919
+x: 7a9723c452867d5fe06947fa97f6850c74e991d4a8beaa6557700b459e298f4
+y: 4ae5605095b89cfce482636d4e0fd2b07e2838fca7e2bbd5f496c4ca3c71ab1f06eca457bb8e7f4a9992451018aec6d0e24d007814b5a8bd8b5ee968285b55e287668793a8ff9a9eb9ba00eda018d29561c5b61fbe3278f91efafde86b81d402a6590f84cc6f0f90afe725e59fcb173e1eeaa5b24ca09ec0754bd438fb9fe1264d040a9e2582645807e9df4462bf069652778cd30db041399407dbd89e5dc0fb4359efd345daf8a1d1093ab137ba8d8fbce2badacd3bb3be438ddc3c45c4920e7e5a2703a40f284b7c2663be21faae3083a23ff4abd381ec93f16c82bc30cc9495c036679ab295eb7c7ff01b0020aad0c08569d4f94b8abaa70ae10097111e901e30c019f921bf2da5ad188c4659b57260b82f60fc7043242bfa9c5749e756bff41474126925652d84a4b18a50c28598b5d8c8efd0ed12c387ef9bbc0b580d5cfe3443267bddc1ddebeacd7b7a456d3b2a84f47bf528adbe825f5fbbda9cf06007f30aa5acd8027c47c76cca10dd9dde68104710559ad3324d6cf046d3416ecc
+g: 564a9966353c55b57c6a42e5b17c35ea70ebe40baa9a71b1de5d72858d5154574d5b4959eec96dd8d3d1498fbf8857b7a31831db381943bde2b05b2d9ee565d9f388130da4d5e20e62c4ecde304b19672dd93bf8bc105d6e46bebb8a3d538709baa235e338ad47450f3a437cc89710a0e759694f65d74fa578fd9c6041ee5078d72dc5d40d868ced67ccf06f01f74faceda056c609a2112ce1e43b6181ce353db008fe783e8d3b4331640ba6c7a6769e917d3bfb3e97167e66bc9e4bcf576193970e93f83c817635810bdb98f544ed82114d8bfc52c85797306b799e40c1ab181d9c6c64dd1305e9a786bee62f83babdb4ea006d953f6b2a17edf8e455549b27ad05374c5ca5905a335d85ecb601701c529e0fd63f4e51ed6bcca4672e8effc886984975517ef28dda6ebe964170469cac61f83c3c8da31b9e867eedd0ba64106995027ae1b4365cec6f49239c0e522e88723a2e4d2ed13433beb155aa806c6793c16c12d232464fa954e1e72e241a17d460435c23be7d4f60e9345d008490ab
+h: 100
+m: a71b2929af46e7543e
+p: ac858a709f5ee49f31263b09d9aabfbe89fa3ef7cda33afb3d8be3c53365d60a842d4ad3ebc6a8d0a2d02b51685df0249ba269e0f0f6655b5071417b282c9312d045d7362a9cbf34f308e939945db31b89c9365e704b1a3d9f14779a090e3746e6544f0b5ebc2d91b2d0f5e7e6c22a5cbdb8e92c13243891da666b7061f3a3a3c11ca48d698e8c8e00eafdb8e7ac98727429cffdebf73cc25ee6809c48578027ae2f9895b619650db9e043f83dfbe3bd2058673c9093c58ba5b4221f6bc3c52d6eb3c5a60179badd6d87516861bbf5c779969b639cf229a6386d73a22b39bc00d82b7038472d6985e2485137061dfaf574176ecbce66617b1a9fe9efeabaadd85212ba5429681ce7addfbbdeef49abdf510dfc949c4b75fe6744b1f40163a03ec45dc5a32027dd1ff1cae99eca4887284933119892aa469af527d212d0a54ea1f24f617b8b0760418b06f38f87a77ac70d450d7a7e67cd51aeeccafc8f807cba2b60a666d270486c236a27bdc5dc007b30ab4661ce37989245cb4e8fd2dfa545
+q: 9a8c0039f364082e3828d98f62316ea3acff181bdab8b1d8ee8af6117d78d2f3
+r: 41815e633fa50a45e2f5e67e72abb0ca5c850996b4d37fd126ae0270fe8986b2
+s: 712e672d05e8bce407746bec1e26426de01c02801bcd508eecd0d58fda2f105e
+x: 6b09b366c3b2aa81164208ec0e8ed5ebed585725befc895f37ae444fd42dfa04
+y: 1d8573838adb591dcbea08d8105459914f575d72ce86a88dc1e443814eab46bab9cdb9ff0cf28b1b2a83b19a4d2805da15d77d101801fcfbb7dfc46c19f61fc4132e3f591006e6282ab5a609ae438b8f53984aa60bde6f127ddc727b999167852b53be146624d67eee9aab3c35e4e8ba112c78113cb1432265eddd51ddb7b66a701d7084c7cb99a1bfa8ae7743eb1b7258a0a5967fa31d5601e8933d96a81e5749a53f6356785cb962d2bcaae3b70a1bacc0348cdf8fd3347b689ea26cedbd8ce05a7c26175acdc66b13b8d3ed81d5baca94c0bf4a9b82e4e5caf07c23aef5d9d3fb3fee2d3e9dc7f31da6983e6a6ff61fd6f9212b2147389534ca768a21054b82e13cd3fb98735de482582a7028ad548808b635a3a7892be503dae2806090b825acca0f1d54df3669aff15e21337d3ccac8b989f3968c2b0763f5e89636e73b0625eb47962d3cfb35720d7df49cfac233b732d2e1075c20965682cf47c976dbec79574d3ed2b1f224fd72a672cdcdb1a55d88ae6e6d8aafa1415fae3d579e60
+g: 6c211aab7f67be64dd75828e176eaf1dd9a5c12c464d8e86111bdcc8a9374c6e03a96a49a0afe383be7d5f56eb6f191013a17bb18f32dc2622d6fa5bcc967fe2c80a077344241c31f939e0f3c2134747e0edbda63e5b971ff1a2f084b7da8e45fdcc86b3ec8996fec01dd71b9beb87b622ba9587b3ea1baee8be528e5a6606846d2b0ede32385b8f59807ee09a3f523254fcdf6b3bc370b84b335875959c09bd2e5aef0dcd8bdee573b083553f658f1f766b5c7174b851addc8b8dcdd1f6c3266aadd97e6109c185b84ed2be6a641f40d722602a54781b2a663dce8746777706812478c6e1b996055d16a4e147a32bca50dc7c6e3cb065fb949bbaef072c50982f2afeeca1ad2e9338a80c150726fcefb05f96b8192590820bef40b8fd3ff8d0cd752864964e7e7274d974960d2469c24de432dc1d235350fef28b41dfe828bee7b7773428f48cc7acc5bad92104ede5d5c0c186e19296ec68fe9abd27b6d50e318cd7b65cf2b2617d77e38527a26aa13e52d3dab898a1b1814ba60b7402058b
+h: e0
+m: 41cff2f02d4ac663b0eda83f2efb939e2ba8c1376e5bcf5e22376a5d8209a6369563d99be3fa9c6634ce6ff0a1f988bf061bdf1b3b7e3fc8f61bebe04c7bb28f5c798ed4858ffa4b65a9297ac8a56ac47e5782fd231a1af7d96e073ae08588a73ebfdd7e8de8d58743f45e18386ca4b3cdd941c94dfb7adc30
+p: d8e1faeb2fd188a8a7cde53b8b3b43ca37df1f085c0a31f675d6da92770eac126e02e5fc3837669362850cb89ab4f325c3ec336bb2f3addcbc03b6843ff4d0bd6a8db6acd91b0c6a73aee84ba5ca3b0b7ffcaf97f6748c103f54f32d0ab3fedbb56fc107c2df192510f19a636606dbe95652b4e40b2d9ef4a91d112160f168e4715112c8ff257aa1fd65a325242d1f6bb3d835a88dbc0965e542d8e32ae419029911c76de29cd85f80ed491de2ab24ec3f08fa80cc972179009874d48e3700041a2eef7c146f7f36b922f3e2b1a525dd0a5d5e0fb58d09e9d368740606e8b9cec3c59d69c57d68b084185a879bfa699e4e7ded1e0dd6d01f6e80e456e35e15c2e38809749bf4881d530e738c5b647c186883a2ac90c8d2dae4c9f79cc550dd1f9bca1b32c14fcd2c7805f5178ade716d6f3b7ef3bd12631116353e22ca5c298b485d2fbd5f43ef024668471facce5016fd1590aee5b74e4bcd4fdfe1acbeae7695a9dc92618e3a22d9112d636b4697977053caf5ed0864f8c7889a63f3f621a1
+q: baf930264ecde018c65874e7fa04024256b22a84437cff82a2aa7ec4508cc397
+r: 8f81fdf43c81e8f64d3b42401c5fd4d0034f3c7cb543690f6e187ff3fc1e3b7c
+s: 498e069e14c41fd63647a0456e9950f99ed59f73516edf9cc02ab4c97d98de00
+x: a91a1f6880a942d147802a32ca65fbb083835e159eafa577f8a958ad931de3cb
+y: 7cdfe454be693a9c8b66e81058e73fcdeb74879fd13c3af7b1026da762d1b85e8997d6ea1d01b9f95896b883e9e9d1457729c953d64c9e55a1a8df4fb2195fadf55f59ae7b5e6f46a4ff35168caaa3076344a65e876c27b90d476bedf23db215282dedb8329d948d62f00004d45579c3017af70afdbae6b90f695d117115238cdafde16cf27f00f94a073d37d89377f7c72b812012ab1a467d981111d7b18d49cbeedfd71ffba34a556634776d879163bd10fdca99cec3bde95e97695432549ce662cb211917c5b129cf757004e2e009a73498ade0408c26ab6ceea31d3a42c1209176fb435729e0cb5e9b60a0a4129e935e9a28bdd296ef8f2366d0feddabec5fc6756c96f25b5c61267ff56b1fb1e76f9d899c0d46f1f4a89500b095752148bea3d7af414e326e4fa0591fdf4b455f489c6b6476c14ff5dc1ebbe6e4a22ff16ef8fe6bc0372c2dfced665942fdf9f1fe5374a5be6782bc7eed8439bc2163765062b97f6c331afc5b4cff28097712f5ea807c1d38dd9d157d583301c28add9a
+g: 246aa59573c86300c83ee53d64bf1a7f4cace3ea40db0c309f653e4231c82104a26333c9ab3aa779ef84b607b273f71145cd3a0dbc379625382be8aa61f71c7d205297335e65ee9ced3ab29a00109b0893aa88e4bb1f3767f45cabde0715f4fa531aa952c65098da52b707daedc3c9626db68403c7b5d88d850ca144f4903872de6b6f622c64b144a7465967598b6d25d057e012ae011068a51d387b4f60faf13e79d96e9cd8d38b10ffd9ccd747cd7bd8a442941e3d422a164b6c43b8351a756daeb53522d3941bfcd4f91a397005acb6c84610e9bf13e6a3bf8bddbdfa69e172a635eb30c78e7d5f7c41b337394c449e411ce5d040f2d5dd03675269f66e9e17554e7bac006acad16c15ab34526290fe78ee8b4f221c86426c832f60697e59dd37625598b7ddd7d57efc7120967b39badadf111a7f74427dbff4cbb2cba83a285e370a8f2f0aa2d8b8de7eb94a4b4037e68e8ecba0b0830faf53c4037e9e217518d6787f00b61e882828941366e86fa1d40c5209935723b8b325dfd432bc91
+h: 180
+m: f8c04b2114f02fe4c8ad7a8f0f50ab2095e3d53fc03c688994e3eb42f70ef8218a9a41be21d7cd52d81ab557d3da2652785232dad130871b
+p: 89c2fcb4f23d573ae016f733f5d675f7e04d6961040787f9879ac93e5d77219d9901484434a849445a87e23c6aac47929ebb3f68dfd3431880d92a8358ff428d555cd5194faf3011e0d8a6b4749f85fa0ec44f276ab957eeabee75e6d19fe960c54607a1356a7ebda002066a66e377c3e4b0758b94500c32f38386cdf8df332208e404e51565cac987de26fe7c2dcb2da7b760d91ee7f1136976aba2dff06999850d48148a4a95dd7c5a8f72674529f2f9cfb942e872ebe2deda1dc923c2325741fce62ffd279cae4bc2f82e8730796c7eb038ac17919f73b30ad2318878b08b7e8dd1fb3e7fafe73840b3a0b5848dbe8e4d714a4cddb48ef098c64f557dbd52dce8c47dbd3c3adbfd2b6d1c9a79914ddd9110b57b0add4fed67f5bd23139ef2fc4cc70ca867b007f174f2b3e5ed2ed9436b8720e516cd59afec575b58f6a8393826a9bd240b2f91eb1bc183ad6d3771922f4075cdd48816dbe52a15c1a49b88ca7a75a9db0e852259258445f3a8ebc668f18666182f6ade41d1c29315ed2325
+q: f139ec4db606832bcd7225f9cfaebba8de23a2bf0bef7c6e7e6da3c0a67e340f
+r: 94c027a53e44370294ac7aeb0026696a5a7594fa5981ebc8cfd4aa2beae182fd
+s: a6f97f810c693b98fadaee961171491d478c496975d6a8d6a69e448aa6dc1a25
+x: 70de3057cd3914c66ccf91b988a668ae71fcc8dd2cfd5f4ec234608eb8b2cbc
+y: 45e6f1b509af74cb0ee5932fb3ed71af98dcd9bd6a6c37374462891d85b3935aacf2e4abf92911cfdb67d7d0aebaa6f03703d6426a3938df67749c4444724c34be608accf82f7839e20860954dd5c5d8417d148f4f3708fa43a8c7d9e63ca4c16c0d46fcc21d8aeee46f71a6f2674513a89c178bcbb7fa700b39f955f015198931cb90e9a3f51137d5f8888caf017a78ad94f3a874260afb5bd0ddd00e8a18ce5f67507c4623ee071685cdea9e84e8b602d96d637e2f3f3f230a6350f19ecedfc38bfa86d5ae1aa9964e8feb16b2828270c8fdd912c9c9b7acbced2f9f5191ebf507bb3b6ae52fc6b1682d26fbe674b05e47f1908abf0a1dc66b350124b6fe871797eafaef7adf7bd5e7a63c5d3df2c815492a94625ffbb9a0985142a8f2e3ab678310aaa5b031c5f2c71df41443d6d5037360381a71bd6d3e7dbc6b8bd2f2aad5ff6da9af039991b34d21e2e1b2eb0066b21ae8042ea6230da9803b34debae1fbff6e6aec96138a19e4f32ea7b55e3a1aed6356a2ad41852f45dc42f5adc232
+g: 2439794053fbc1ad5dc947bd900d9055aaf605e4ed189bb186f9e7d287c8e7d4d811be0e7778e86408734edcc04c4250b67a6e525b9257336c0161db48fdaf031a2004115550c78437613a0ca4d6cbb0d23bd4d43e0667ae8f4e4e2bdd1ede22b830a289fe4b0d273919454f22681e12b66007a092549bed122baee5d507d2012bc9fc195a54689e33162f1c4e5de7e73a8cb45ca5f896aaae0db2117371813ae0ba966aa29705806897d0571e808f30f87c4de3d71d0452e120d4844bcf2d1c6a17771103ab3742a4d48a1054b3b1bc4ad607962f8ec818c20501bf17bfea56e8a4892b2825b53f7d60a82ace5c7bbc190724ca303f15896df50ce57d975c602d90a6378e710488942dcfdeb79806ee17211f77c51597719a076c7203270c0afa4aa4cd1f74452d74c74fd1d92577a85bea21c65528e2eff8c875c5e1380f511d47b0e30148bfb3a8ebe212dbfbb44e2081657d2d3e661ac8f63479e90441e0584df9256a7ae832b494d351df7a4254370254eaf0d7f316c6cbc2f4ad621993
+h: 100
+m: 59852f4236ba78cd9f2e6ddb4d5098e7d50073e550a92993a162546f439604a44b915b9133c8c2de2fa2def32118d7d51ae426f11f391088e082729825a0376e9c3ab24818864c298b7d304b3f6adc4258f19112a37625b23eec8f477f389cf6c89172fd1354fa9a57fc73b6368343829ac918bcffd47aece5507b61156150f22ecacdde4f8b16f8e83ac62c8842ce7a1e87d70b3cc3cd0d41dacf8618e751346605d234ac7989414e4d692b95c7f202bad0c0e332297151eddf7dc416bbd7c2ef841bd2bc3f8fcbf3af3fda107cf8cbc576eff5
+p: e82433bbdf1b0342d22306244745c9d76dd07a6e8b291c4ef4b13575e7dc9beca812faa9296adf84c92709218ff59d4d9b03d6f353ffe10bf8bd744c687bbe1fcd50c15495b4007801be38b21b938a7ae7572b2d46d5eda936769dd1eb4e60a080d751a4b73c0cdbace113197916a33ce0a68f194276792eac1def1fe864aff03c54c0676adde24b1027c92ce1b9989fbada83272742e9a40ec035460f48080de3461e779cb8cb7598060d720bc400e8d712cdfada9a1170e7dfcc024d137145ecc84f378bc6a9dacf67fe636f85b758821d826c6ab326b388c99ec9eeed0abad77582f4cad6c68d6e01b5c2514468acba728066c98275efaf123a7fe33bd57211e4c9c6626a54a50c35499b88e6ed217a315541048b7a8d8c0780a8292f471b96ce7d482a7e79bea18cb33ae2acf2f00bd5c486dd61627ad574c7e1f90446537c2b2f60553fdcf570dc87f91d0a6d9ebb644ecac4309fb4b45ec9952b3742ace82a7ce0035163dbc3c378bc9b7b6c8b10affbc58e4de7beec584867e9f3c2d9
+q: 9927f153e3357e818ab74f37fef9e8179088f98f3426f086488b960dae77a475
+r: 3a8b87dd16bc200c83cc600848704bd5376a27dd3322e0f6d86707dfad1315c7
+s: 11d2e1140a88837eea7c8a2ef7b064f1e25068a5911d7ebef19d9df03a54c0ae
+x: 1e8e5f046a7dbe29d3e38766a676e48f78ae02c9bf20d3fb937efe9f5ecb7f54
+y: bb70a52ae0547271bb4dae20efc3cbc92badca851ed1529fd126da0bdd579e9e06df7133d0f96b1f890e951534096fc59bbc5bb316c6977b776f2d82cc954d57397e14742b0c500960c7d942f116657ecbefe6ea54ec9a07dfdda77d605cdeee0f58b7bb7b3f9d0a681bf1c24b22520895a3a9a2991cf815641fe0c3b01634c7aae4af2668a4a07464fe430fcbbdbe56718e9af97ad6ac88e316ebb778ba4c58788280b0e5d982a9bd9c21f7209480527be2d5aac45a07c8e6080e0e84c804fc52f9eaca35edfea8ba285882141cb2333aa524b22edd9330fc8ff3e256264e1e2f755d85e873ef558c3ccd1cc0aed3ecfe534da328d3095011dffcafb70cc0bdb469a0b485e125f4b9225962ea007cb2b427846235c3cab9e09c600245ff43971a1aff04c6221c630753c3a87cf12d71edd5d33790d2d3a8757aab0254b438ad53db2c3318e62492e00ccbc8fbe6ff287e82d25dc34a50e454d2f04df088a326312e29686ddcf3d4e4396c73aa623a0b785f6d0ae49583d8c5c0c2c7c21b314
+g: 90d56047fe0437deb0c3eedde6dd8b8c411cfd53139f5b7aa4c700b0e8c30a54572c039bf76eca66d7f80a9ba1033651611dbde3bbda18d54d8a8875dca65f71766c1b72148101b2d702ef9b5aa1a85c2368b4d3a4c9f90126a1ff47ec9a75efa4c0bfa3355973cc8708457196412151411d3fe12e09a72aa6fdad83f3b1a808289d99977eeac805908981e7c2a38d79b601a1222bb37ca0e9c14284eaa772153cf79ba3221814cc2d7e2f9c51540d7a3b23814fb40a943bb578a0b12ca5f7eb4d810cd7afc051410f630243c5c5b7cc672e778cc4b675bafa90b2de8fe1fd613caca26fc4371cd6153c964afc28f635bc751be35703fd587b36491a006a48824cddfddb9d8ecf329f832377336922b27225bdd7e994d6e2b93c36f889de40cbec8e23832d082c3e3ab2d556a3c18ce8944ea04001472d8673d98ec9c4d2ecad98f853288102c78cec5e28b587cd17c0266773fe826682e3096cde88aadc23b49cd422f9cb8f68fc9ede7a9887ceefc2c8554edd1bb5863d58448cc79ff6a0a4
+h: 100
+m: 76035b3bd6553ce5c469264452d82458c4526be46ce94416e5dbe4289ce836f6682e4b48f37dfcc4c5cf6086e82a29bf61a9ff8d21a1ed239a7cd9d17ee981e62ca6e3d6cb7ffcba4a47aaad0f884aa1fa8fd9dde2eecc734cfecbcd7b1bf73a72cb47a574485b55037c95f0fd61162526c7921199845133bcb7e25f5918c134e4b37e313780b2c16f5afc225fc1d9a058b5a82a002075778b3622aabc953573b4fd0fce2109c895d2d81d7a1d7f565a9b26bf74dcc6b8ad8624212081e70d4c894bded18da63163ff05cb7792e1cefa8206a4d146b2004dbf095cded6ac3ade513b8978d1e321baf49614688bc52b45d77f4d68b83ae21c7e92c8468f86b3
+p: a402f26e8ac3f9a578f910de96aaf4cb6e06bf66121c45d3d365331f0bdaf099e90ca7c09373255204f19d3e747a0de6fdca44b0f7294a850b158bf1a77c5fb934f78c35f525199090bfdbc2e0190523eafd01d3e87595bdff792dee18a857f1103c9c70a3a01874edc124fb3e7adb22202edd48d950e5771cb722d3deb151ca8c37b0d028c26006003f4d2619baba2d92748d104023889d45c4e28a99ef537babc839d153168c2ddc1a98ce7d745c870192bd69f16561b90e5aa1ab3f3d853bb01bdd0c414c980873fc97c04602edb64cc2f97143ecfd98581e839557a1bd1114d5c0af803c274e7a55108c64daf601286b0d728ec9318025dafe80d915a9bb0aa74be28890d01fe835021974c3987b8bcf21e7852cefbbfb0b4f3af0585550ed5007a06d4dfc9b41abe01669810a8e3c1f85c69de39f0fc5111a51494c0377c75c8c9114b8ccfd03701c81f594dc0d5f85807f7ae7e89a536b7f03fa2ef3f3d92c03d32f821a293d1a044841e55d8b969a09905c6876756f3c93f0523b6e11
+q: a128342cc13963a072d7e1f8fb48211c64d3fa9a88a196879f827fe2bf5a5e37
+r: 7b9b903020b499eb52c02fa2c44a771507f7ee213e18739fe6c2b506257271cb
+s: 7a75aa9cb7047b9be0b2bec8eac8b6d51e1c0c335380a526ee67d8f7c40c6336
+x: 463d26dfacc068729cdbbd33fdb014ffcef9913f0cd3745125825d59a9e594f7
+y: 165f2ee5c2f0a86bc3af3a97e9c83dbe6f8b046285316469736a502d8efa25c046a7ee2b541d18cb8ba68e29afa814180eac1a60f9da2d858167870699a5a648247aaf0d779e90a76d568b236a9df05fda494a68878c4f14fbe3ede875f9746b2f694208c8df9d93737b22589d1b440ed2d02e362465a3d7c573fc947842e7169c3924e586e2ce6cdb6b2496b1e0ca94be95ee98aac15422f141985e310484f71d6861623672c3ec448260b87572cf903202d73dec2c577d2eb5b7ade7f706d16350359cf6d07ff83fb82111050d1f36924299c10b810a0ec2b1f2647b96d28c719a8757ec816a7692e026455b66fc2a9cce27f19a5c69733d21713e38029ba5e6c45a72329a8299897f907626dd3324d3494e00155fbece2be23efdde7dc55b14e945c4758c38f9c00fe5631bc5b5f4ae2b74079b3e9268ad7b816ea5085c423b1cea436dc34800e970095dd888b383de553dc963b0d040093c6fe4c278b28d64ad722c55627a87b5472ec9b4996c9acc91c0a3aeea39a30702e366dd50c658
+g: 5764707062116cc99172717ef717efa8005d28030727cd2fcc6688b9a834cb19a767f1628b9b63b3699b812dfc0dcb94c0ada4017922f536194aa6515a7d30982b083fb169e57393bf90b589936e4f187359d34f4f538017b4f4ac76c9fdb1fe2e9f390e4e1c21d6ca55d94e022e84482dbb9d4837dfac458e6be78ec2dbc3f4fdf4936e6c8d14a1100864bd8c57dc5989f77ff6b2912978126f962e58ebfa65a5de631b17474d8532d5d80f417e28e2de5a2b54d88ac0c198132e750a8f77d92933f977b53cd22ff4253692b0beb5d6b8bc8a00c93dfd4d5d770e2474b361bef7f452b2969b483e0753850e0cebe9e4bcd32748bca7e5935eff31736b8965c7403b14ef4f6e0b014466c24ffa48c25af65351f5f8c3094b4c4e52c4c6ce8eb85172c56c8d5ea30e9dd95deaedaba7fae22579958e4d1c1c156e5443b023864ab8685b3fcb1c98094dd36b9b05059b8aaa2304dcc65c2a5ab2e6c0b51978ae1d545b5e72359be8339014976ebde8548fc492002948908212960ca3e40a6ec6a0
+h: 180
+m: b711f04ac5fd89c910b1c0e582fabd78ca0f57ffcfa42c346a078588689fa371ad03fb4852915160f47d9af4446f720381c5571e8c5e
+p: 9c0a94fcece70453cfee19ea72714e33761e57ae6747fdb63db3d76c462abb7928b61f9ae467d7d1d9796d8941b5aa47fbcba4ebdce760272fe644e90788591400ecc65c5e4beda021cf5bd761cf34e9ce0866e7c93dce6344e6c6aa3c50011de5040bd2d03e3af54b0f78fb534bc951d008a4e3accd54a4eb666fe479f6c837d8766b2693185629fff8c88f2c3c2bc7d35597b5ebe7920f3d932471e27f78899ca97f0c8bb25438deb9f3e313d1947dc52758b00c8985557617f411e96a536981054051d39e67b7a38f8f060281d4520efdfef4b832f8ac323bd5a18336e7fe17a648b106b3e5347dc2847d36df0cb63a1c33e2827abf624a925740873419f9440160936ac093eb5c5343d04ef8da6d0653b268a227a819e61deb230b94071057a58f818df4198d580dce76cc5511ef968d636e32892633a0ea4661e6c7d6766166ecb435059e07c102d8969dcda065265f08274326a53755d5d73956a16ff1cc7c6708a8eb2d5b8a15c8405c5cd43b350b036fc624912c446568b4fb435f3f
+q: 864af34f127a0053b57efda497bc6716bfb8d994da1673b73e5fa76c5eb43d3f
+r: 9d0125693a02f4db4f05fba2cd67a8cde6a09684102be94a433e57d8546a6dd
+s: 20700ca03c9fa80b12a6ac38916348f47eb63c2bc2b23c7ce34918b2b2cf876e
+x: 22412c573b55b3810506821515830084286ceefa19c7a1d64924e77bc02297a0
+y: 49e202074ed99c408f3b1eb8f728be5198208c35816ba0980d062b55f0d3d6e6c88c70d3c3e3525c56e0596bd509f94bad73bc842e1876379facae5223bbd41686628b4472ed8b4f39e3a79263439d6736ce9346c9b94a6f72b18e86acfeb0138b2154f3f1ddc1e40ebcd4aa943d7e70240e778ba63d039258f54b85d7c402f132f069d9d84010454de8e6eef7e5ff9b08c68c8686904119bf2864e21ef7eb9b8587cb6040bed7bafcd7b71e6edec8ac2aed8f0c21718a0441f273e737c38aae2d769f22aab468ef82014c6419a8f9c717b40064c7badcdfb3dd873eddb0ffa29b540d3f27b7612e983ff841116a0c552bfa4db4a8225af7829779440f6224d1a5dc00cfd0ad533d8d10d4cc4e2d7db62f38eabd239a184c68f87072cde722f6999ce50b1b56b411c8068ff10ddbfa43fc64b96862f686ab437e6ca9e6dccce5cf19756b9905d553acc93a6b4693092f1ce1ac174543459a7caf0e8973495168f30e8e1564cd2072dbe250c09c8834e4dea3940c38a63db92334c126946bd648
+g: b52366675b30cbc99d71aa6b47f774d84c1913ac563f5b5bbaa1e8eb604fe8b4626a128e90b2e1f47e3b0c6bdfa8ba1a49411c3fe9376101a70696d913487886efeae71b8f0bda37e9740089bc80ef8e77bfb3b9579abe7cce8463eb45cb2b7797a3c8454cc7fb45034e3dbd05a30af54ebb4ba5392eaf7f51ce1f6341b16890fc153a6b0d365dc1f931b5bdcf872b0b1b3223e2a2d8791ee84bef27b4032ede9f3ca89e62fe56d2676ef6a52cd518bd57b3084cafa629577c9bf3efef9f68d770a617c452f72d551cd1e723687b5e9d8e41e3630a6660d507545b82226c3210a6aec46b94bf14286bf078309f13340ba59bde46f6ee3254ac44a199416a12f4a8187524446643f9cf69a8e882d7ab77476b6cb137b653e5cf4f93b33ebf7bd516b87f7d39266d0088758c94d7eda81c9075dfdb8ce7a9bdc6bde60df2939a12fc1a455fac1893098133b209783c6fd1396c8bb2110e23ad7e3c24c42290136978493231de9c552d5b9ee9e53b286765f7240e2b2c16ade943af26f63598ef6c
+h: e0
+m: cdb6087be618f5cb6816b019752a6c9b1b2a34088844fa94c17ba5e12c87b5e01298e3a91871a207efce74e468e4d6968671a68d16538b9cfd13c150869fa128750a66e4d9adde677be2da3f1886afc15cdff6fca2494a112b1bda966e1c0d71955652c87813ae4314ff6af24a1d5eb4c5faa449e6dd4aeea7a4524017a7d42583891658256f15d29d058fcfb89a501f661c4eb4eb7cee8aae4cae8eadbe3a3ba24f117bfe377dfa1e2957a61e4d81
+p: f4b0f3e4b4103c527c690c480004166ddf1bd21c6c8a76af29735525f8f79bd009e8a2116e38352964e440e2a4974a7f84a235d21c263d93766362387ba62f791a6fe230ab31668294f7b3f586196f2dcae2b7d45384cd15651525a27e6d4ff9634f7312a4feb0b3ee70febb01d7a36c676940ab0b6ffe5d8082bdc8ec5c0515e2085233808b834b3817ef5fbfcb95efd8c8f2c9db995f02c94c12a478f0976a8fed28a04f62f867ca5862a43392f9ccf143c3423503edd3f0170b1b2e3533a0cad8efbfd67026e8f53a2c16c6d838fb9c0a5bf182ce06304a1e97607f8d2fb52e02385389a24c9919d6d839f046127bc9b848715396f2d1d2c16592a9437d37ef39bd7d2cc02d5c141605fb187f51dc2c27546aa026334d82158b6c4683453dfea194cf41d909d1236c00b7d06be78827150d4a16602b4a5e47f43d83911e4fc52aefe080b0ec30ffad2b3e61fb25a7621dd3115be40c58c6ed5fb51ee55b14f7a14fa6124097c3f0b01dda122f8e6926cbf56d7aea8f634983fcb0325c5dfb
+q: dc7dfe844fef142c9ba751bdcef77a0c0d406cfac2333d94ea57cd4d4f74c9b7
+r: aa4bd24ce34f71d6bfe8c5962c418e99d6f001317c02af89d5eb85e150cc3efb
+s: 6bdddfce0fb4b45820678f9fc96f671059771aceec106a4a4c040d6796dec18a
+x: ad5beaea9d375ac3b2f051e4654eace6e69c274c30ef1e7703be7c24bf2637bd
+y: 87e156b6ec44d4b2734e4d7cbaa421cc43bc30d475726ab3f2ac57ce87c7ff3e23b1a19eb3224ade9793bce23de15a4c5c6e7dd21115b9026bcf203438c8ac266137f92b758256f80c6f6f90a30fa8ede207c28f7a7d7206605ede85e3fb3ddc940af10360d2f12f6f134450afcddda5364f20fde312594a594c7e408e5f9497692063b75f29b4685911fa7b2e6dcf716c8c4db8702dd29589654b8751a2183cb7a8f59a079b725d10771d185a9888ef7f87ef8711e02f19cd268922169fdbccc3a35e5f84b8780e829ed1524a8102d90864f62c986552aa49af07fbfd5c003bb6bb27ad5f6af7805cbaa31094c7d8f40933a05b66ab94aa8633f4dcdd3ee6f17927e1d056441986550a909f401d81ba8164b8834aaff1143e6181fe781bed105a236409c9b148d5253dd13f1e944da61fc44b71a2baba102792e5b101fdd09a042e917f4a3d81ae60e6f462ea0f14f892f963443f7eab34ecc7c2214f65f4a4e03565f47a0f23cc7f4e68447db8c21301563ffa884e6b3adcea96a266c29f44
+g: d713efad64b087c2cc9b5119f6297c70f61dc1dc532241f83000d04b1d6bca0997d762780fbd77313481bb90565a395aa79e09c7229f2b0d07fae2d08ad69565cdaed4f2fd50137ed6b0766388a7c738b4545f8562c342b09ac6644e3ccfc1995a3f5a214fedd5d6d5e631c728e87b65c9afa5ee20fde8c87962e9fdb30e0b3d974d90fb9418041493581fbadebcc17c4791e9fe928f41dbdc34cf0d30c51fc656d5e1c53732a3830822833aa96d0456f007c480fa747f9cb4f821d64b73314c3b47f333ddbc8b438d79979526e0fec835f33803c36c99586b87c63e91342594f785bb4a495e7af0277c09ed200c9346f825ca62db2063cad829ee1c5ce881310dfcfc6caa8ce70a31cc9fc325a7e2048b226a2fbef1c0088490841e89a2fc8e6686a27c60e4cabef23eb23b721c5d618426d4890038d6ab44ef55d935bbdc0376c4444ac0b85b872e64a3a58f55a44390c7cdc7431f5b53152533b25661fe5df3e634128836d5e6a76ee381445ab73b1096ec9a2b2ea3b02adab1a2df4924a
+h: 100
+m: 5f86e29f9ef35c4930273fa1b480f5485c8db0229d850549d48f4686df121b9ede620c411f80a355cd942273358321e021c6aa8b11a33d2f62dc506f74f20fc7200ab2ad07236b5dd3d77dac35598fa56169a48287603ad97103b00f8c32f5b455d0350e184a671a7e12d7e97b6de4d589642b9f3df880e0c8c473bc6142b73fe9d4be6c351b0ea024bef4f3dfdb6a6e47b2538f539c46f494846d18670dcddc0f2a9542
+p: 9953d548a719f5b6e2d5c40c5402de5753dc86d1aee25f17fbab2658dac058434c0bbcc7fc60e6e436cb568f34af2be3526b388a32e07aca68bf24b0f955f4d92df4d9ff2909ffa251cbbfcb3366d1a912a6ee685eb29a35eba9853cbf509491a5c6377f205f69865a60cb9213a64d04b8dd6f399f5a0471d62077bf15a6d2eeb42f0585a97f7682783357f2822bd2c986b340f8974c53a2b1c18f0dcd6e2148acf58c2a636339fd461ce1d1aa85a14367bda77ede7125e846d93108a9fe4213acf6415165041b5cc0ad4994c812b4c74a079da16e021af1b8356712f32c4d3d1dc46fce33c5f568a8a046ab1b028f528636359616fcdedee98b16e7eebb6ba63e82e4402005c8f5340addb4e494f906730cafd22374f1ad0ab2aec4443b02a7493ed850481647b23b86f05428b1004085574252713682822c0406c86927329ca8294b6a8847724e2a3a6d274ead6608c96954ddd2c153747ebea52ed32ede3629aad22b5bb8258a205261c551f4db7e36169d3379c8a22f18fbb549fb006b95
+q: d307be73371985389474519e828f990b87efa7c47e65162b7cd3f26eab91f471
+r: 1c2b676da8c57ecdafab5988825e7c274380877bdaab4e5e3d949db999accc75
+s: 2bf2af337e4701718c7a3531653b918cf4c11a82944e44f216f54a77295a0c25
+x: 2fef5826efb21cf6fdad5e67a56d2c94086bd6556123133d922a9c2d7769db97
+y: 799be060154973433a65df1484588e58909db6695768106373d0b7e5b04e191188ed9c199da9732eebe985b092d4f0ca804b305ea19de2b46b2d319e916e96767fb15fe76112d796dcb5aec065ea8ea3c2922b102265672455c1105f338ed4f55593deb39d7150efc230890e74d39f9a55e9138397ee4bee6322aac99d7c29073f16871c988ee0f00fdacaa9e730e72dcb7237e6856b6cfd2d61302481a996443dab8bf3040e29e3ee2e6ba33949289dded2167eb7be933042dbe5a0fa435f14ba703fd8b6b74f9f1e6e3d4fcf56da966c0c48314de97160a901b1f32b00605983e27875ca5d3cfefb5101fd582aa2a05d47f3cfc266eaee5a139842161cf3929d3d884912efc11db2c39f26e1a13bd69ca38d5fb9661cca518f15d3f7b2b710abdf57f9042bb4a8ded22d43d2b66ac9e6156f75f1b442bcfd2b1526bf95e959f8f846a4bc715f6503525406c2a93c287397b59ae820e1abd9771ea50f4e37c8796988a4ef7812232d991257630ccbe59910b4f52c001d6b48dd6836c220d26
+g: 50e3684ae9af22039f636f7c47a7ec93aedeb3ae2199c0af0ea0ca0e6977595ea720e4b963d52c68506fa094e812af8b0a6f90b6accd87dcbfbdf857af73c21c680b5ebe349a141a78af969c5534afeb929718b09c1c0d25fc9107778620d8fb7fafa89626487aa36474766ad96bfe353c48c2421384dccc9e1b84ae71b18c1426354315e70ee02d6f2ee6ae33a065dde2d00240c626e6d9a53808af2b7a58e90ce6c5259b78a0c40fb53d6074afee5e29be15e70b2e3c33c753e37a2165e0eebd3c8fd3327186cf81eb9be1d19ef67519d12c1b40df715dcc1d822376180bf2c94b890d24bb80bb2302d5fbe1b175c206a785c9c733d01eb6540a43c3acec325a78f87bbab5c471945be6626c3e6c9f18b8c1bcf2aa771b59cc3130d3fe56b6a327597b724054bca2a9ec247b78aedf960df4dda66afff397f278de2c3ac4e9feed3e43a56d75d5f0a243f9cbc11aaa3b34d274f4e2e71d94f3e9c61957a041b1aa7e34a8c3556d8aa28d66cc590ffcf5b9868b8e58de8fbae3fbbd1218bd17
+h: 200
+m: 3bf1060d97176213b1879548b06188e007f3b1ce6ff47f262d51cd510d1e3eea893f706f29bb4f2aacf80fe973738a063560cb09528ad4da41c5ba92b72e4752bd983c75b056dfd1e2d5fe8fc712f27dc3fe15dae447be7cf85c82fc674dd087dfefb21c4dacfb33b84650cd74d27d991cd22e48a6f0cb0e521b503d1115eed48500efbc61ea2a8cdb9286a7a9a4f6c4a37d06eced08ba
+p: 851533792e81443e6e477e8cf99647cbbcb8a028e871484e8eba49ba7bef8fcf248c126c644b4f0616e3f4ec822749623fe419ecad79af4dcbd16bb6bdbe7cb7694a6b991649edc5bca86c2eb2ef6855b8952326c70c3454b4dbc42429bd50ed9654a4901f1c007e4301170d78192f0e479b554f32b1d5708bfacee94a89c1ad8a522d08923393520412d4a1e47cd8679ae44a6bd5f531310b2898bed1d9490d4035ee4d9980b4b6f8bf23fd2bc4e5833844ac36768004cf977c6b8601a91a14fc782966777f72fa11edc8296d4f52ab4106eeaa00826dbcfe60d1c64863d77e7ed2a244d5ea7654d7c630af2ff367e244356afae88cfbc22d16ee54d7053d33b9f274cfea986270be668ae6c97ef19bc41d4f876a768e24fc9b0e45042868be36e950069f3e3044a1d41bbca352c6978e08ebfcfe3ef07bfc11c43feeb7e95b18692c2b1eea026b90be4c82e981ff8bef9737ed860c5476013c673dddd6c400e2cb68e35d7eb136676955f51598a48ca4971fc8cee90332b52d082cf738f65b
+q: b7992e8e0e3bfbf9507b2d9d0882fb5375f5e0e9e753f669ce6344279fad1cdf
+r: 18299fa7e2de9ed0b083d53b3d60fde8f53a74aed8a4e9916ef4c731cbfd5aad
+s: a0f9fa736c98a106bd0014689bcd2685ec0e03d4952cecda22079070c568ee19
+x: b186219e231b37ea1c7dfc17d3ccb9053eb90493fd7d24e7606a272c093ed48d
+y: 1ea9ecd257062b07a62f835fe45dcb3713589307acf54c81239e33a8ca016f441047688c37f8839b291cc74ce19760087061153342716c00f61799cd79519ebe1da91c5094d111141a7586e35046f642c890d927eeadcd07c76a426f0c2b2c06946f97b8e7db018985ea13ef1bdde77f806886802c7e0e8b0eee6775c9e9cfe453a183012bc34eba355991c7d439f8b9a881379589ee968979b970264ab4629ff662b64a9d601567714bb27d82c46dda2b46bdf727f7b2f5130e650fb182d2b875bc0c39e726c763e998b5990ebcfa9dc3e60dc7dc1163b029dab939ee6bd89455f96da7fc94cd2c6f9ad187c31d6b6e97f17aaf2ec33b2a5e3d65ba170595d793c36a7d699633f752016d9f2881c73102b05576637dad84053fa750c427d13644883b4b99b412fc811f719aef5cf7766a5baa449c57495cfa3617ff7cb8473ab3e11ff03b5f545b33a831d7636a75512aec1092ed4deb77dd68c60177565ec3888384e97bfc7c65f9e856fee08782a0918c30195f64332f7b6fb5a46f883675
+g: 38a1c6f59bac2e9ff7339597b2f6fcf6b7bc6272ca27479b99ef8a2a6ea6064105496edb6963287fdcc9a83d8e70ea1504abb2b505cc9ff6dac7d2e5579d72f7c3522d963b4fae9a5faed229530fa4a1f28ccfc0e1e811067ec91e65fff3a3353a831ab9af34965f5fb3979b43ef89c8d7aacba7c3a304dd6ed4b848c749f68749756ad8fd9fa23eb719f37a007ed9338fdd33e2601f184be60e6ba25fb0b58e9f041a25cb83aa5d86b622ff19e3077a9bff79e9c6063f1eea509e590eb60d779a8a00f3e49cb432c7dfc825bd0c93583f0e1c89e7d1acec0aec83003a928d16b4e18184c5ec0224779e543756f20951b73942e7ff89239136b134b08288e1669c36a676889ce4c2bb4a845f1bf44b6d9968ecea57f559c122aaa2892da42592761f65638da0c6c0ea2afbf78a05b8c42e0c6c40bc2150dc33a020d740ac0534ad50713d0829bdc4f7477c98b35773a958cde84d535b07e4108a5f848b25bd6d0caf383eaab4bbb49741a690bd745205bfb3150b5f6475a936df27ba5b0dc606
+h: 100
+m: 5bf1847e57ef2e2ca2e7bc0bda2439bb7371c0d638373d1618b0a4659c0fd6f2f525593b4ce336adefb8a8b465d7fa8e836a7142f9e53a4351856c268270a98cf824d1ccfcd1dd89dca9645040ddc989c52db0f6ca6a20e988912df86f28d2e57b53a0920be5bac2db84bf5525df6c2587e4c1ebcecbed27823df5c2635b9ffa635c0f68023df2ddbfac63e73d624c4d21c2a27905bd7248d8da2be324bd364ea8c1c4d3d1b1208dc5895beb52f57b73131ff0bc859d609d3e1cf4e3de15744f669325d18e6671e969d4ea70b7a3fe0b388a7720a722d65257b0c66167e716aeb292000c72925ed7cc801d63e75bd60b
+p: bf1d45c2f14defaa83dedd0f963146938158c49880721cab543263454826bec0262a7be17dfb7a412728b1991784c228024b178fadd063a5329ab903823c2e22d4ab66ba73fc267288935c7b3c74b3606a97a010d635bb47ce2a5cf1f08fa0abb3dc97e8e0a2ca1adb0f7d4e408a6f70ca262aabd72a2e6ebc72dfc5a40bc42db54e8b3d258be97aff17cbe9255972adce24127e839d736af6b242b87a37d8dad93cfb70121a26126ccd40984b2c41605d9a6ba5d57be75125d553471110526539e59f938d4e9a58e439a8591626e9c189d16188fb28ec404377052a8251b43e0ea7ecf5c3b792fb02bd50739316d9d3b2234e7c4a914bcd59e09bdf7c67705472207019c384f6e6d3c536380beedde79e8e1b965630061975c54ef3a0228485261279d94e41877b00e31c5f85d8b0f5a185a211703b19b0aa45ed2b51f40f0996d9bf9d741291fdf943218200f8e3a74e6063d0d0cbf6185d752b6ce3b50ba6ed9806d3dcffe4cfd73a748b3443939672c8450683091f4da8938e78fd9fa4e7
+q: bf203a4717e98b95fa06af9d41171e2737fb3b19f0b0be58f9ef46a583572c39
+r: b8d5d2bde478e7369c6f431037405c6d96afe66c4417ebbe27dbb1074592716b
+s: 250d8724c86de34350406a5d5fa0b881242a477066cc3884ea5261efc049f27d
+x: 3a5415ab661fef04c90bf52ef2d46f01a89ccf571d936f3290fce5da0655cb8a
+y: 3335ebc838937ba51207be4a5cc7ecdf6b7bbf9345ffe9e8dd992caa029635fe21c993b4a6c7f6ca6929f1ef9bef0da067437280071e7d1773e1ea591bc7658a0a88e4bf6ca0ade13ea5f6339ed0eb8f0e8319c0e4c05f40856da8e3c40de2dbff93afa7f50132e3105eddeb33ebef5eba416549b31afe1b4ff9ea9df891790462b94a860371d3c0be772826ca92968c9b7e6f38459d8b101310a9dce49a4ef65e767d0960bee4a9dcece1840260907d0d6e5c9fc6ec2c568a5e0bc13c502dd4847277b022a10ef564464a8f139d4534ef336fab8b7887e88392fa58fb1630e098aba05cd0a909606f14ef93e15279f818054e9090462b6a33ce20383b89c5cc4ba0e5b03d44a3a7df6e99cc555d4731a3ca406ee5b6bb3c4546ba620449bed3a4cd7982962e7cb8f7d552353732206d03e763391afff6421bf285f779d6bb01a6a164c8082503be965657f87a181c1f99d28ec4ced70aca4a89e475e5e9bfb8875a96509aea6ea8bad07cfc709ff37dbb08b5c47888f7604728a9eaaf62ca3d
+g: cb1363519f3a5d78a8e24b3001c589c0a52b65ef4c52f67c4eca26eb9d82bd439b6772188f60c322709859ccaacc59c2a503813ea8476359fc7d75b619182ec41cccd3405799ae9f3e13e7b286a6725eb48b45c93c204968cf702912baf988e0259564483032de41b0dbfa662f8b295dd53094f075a37ea41e990eabdc64912d063dfc017abe7faa81303736b848fd9dab8f9abe353572c63a9b67327ae04f025ff6712adbb5a5fcb600309b32a35778d3e0a5834e75f5724a4f380f0153fcb7f8537c8f4bcaa559a5f2962878a73c9dc8f0b859765f6c14f72fa8ba33e1ea0c53da64916ffdb609f747559046f5b7bd2b6b46a6609dda375d4225debf2a6dddd9950bd2445b6f30674496543496eb4bf6df3e8c625a8d86f28a9f711e2195bb62be66c63455a85ae17804cbfcddcbedde633ba1d76d2f716d5fec58e897fc4caa7a67288fdd58c37f528cfc3a1590770342d1f01511d77c517b03c73e1ccd6f97332ff17c6cdada5fba582bb1cb38c09843f2bbe6b0211bd6d8fbdba39d1600
+h: e0
+m: cad2de0ce06aafa9772686be13718add0f2a7592626d4747942ac1e4794de1ebf19b6ee809fa3256ad420ff27bfec8f9d247949014ce52451844ee43881b877146a8a0527819f2268b4b7840
+p: dc87f9966f346756a165953f8e5b69354a1e5796912c647bf0ffdede76181689354e053d09cfd49974ce6ed7b3bfe19601ef0b41b1e88656e31555dbfc7c99ce10dd61b7882349e59c0d23843421f0d4719050b933391b83b9506285536c272f289e74bb1d74e4419ce911286f4b62c70916645b8d12ff06e1af1519f4b627906651d90bd40fe6caf56098491b1eb45d1c5195d673416bedcb13b8f632e0f4e00da5147c4b8f48ae06738ef81d6ee63d5456f3e002ad5fc7968e86d0fbf0112ea34cf602d06691ac69a36d3262dddb5363cd6e493f329f4365a28a0dec7227008eb6a3752d8d5669028a9210933aef75125c516841e322f8acdf64796d2e345a641d5fb3a3e950d1bccfbcb5c7e784d125f728a9af3358c310ed05537e66aa3539b48bdfa9f597fb411e1c52e4e19320184b20477ccf95c0407f717dca500c7eeeedfecf29daf1833e85ed0f31b08b2784c8cf3bb87cd2fc3e19afd44d9bc35e9589e5d4c069502656bbd73bd07e76040fc8beac36a7ea36b9be10c5369180c5
+q: b6ec58b0869cccd8c97973ee2e37010b9021abda0cf8c7cf7f3a60d98ec57627
+r: 2e68a6610988dce53b6b90a8387221910f700f61039b7a1e7e4ea061bb60ede8
+s: 1830e0b0665f20e98104f2aea6f8386aeee00c0eaff4b19b6135a4b0ed44bcad
+x: 329f1b3c755a7cf792cccca87c92a72ce54a96fc4cedb19309e42efadff2ae8f
+y: 5df5751fb98886f4c34e1bc51e75f5e04337b7cb0d7d4ba3d3a0abad5b9b205977955b0c7515024257ea833815a0afe6c2d01777b550444d3c54ff83d41cb889fd7a148500a29ddf874f4fef747da9ee1c84f2213643a200f81dcc57de3ed9697043261d9cf6ad01154dac9fc9c932c177cc810fa53564f3a157534baa5bd5ce343dcdfc53495826784c8a867feaa95f6c43dda4f8231f9c0c8c232f4966078d6cc65302f84cf85d9f99aa00158ce9fa789d8957b2e4e8cdd174b5310dfb3f560982f398b363d04c885c2a7ca8b80e8e974073217614d1b3fcc247cb78c55081c23067f55d457b85e6b5fe0de3c4f4e7a463022014a002cf517d09671aafef8dca7e3c16b74527b009bb9977be172e85994a3e7eb87a745c82127293ff9f9ee5c9bec5a38f0b3af5e8dcab229e3aeb10f88edee402b7a8fa8f2bed1b57a74d65292d70849a7228ba39affe2708084d432494b05ebbecd0c18599dec6ae1866bde89c59eff898e8c76894b1aced83e323c4926c9ffcfc1e57679da776c1d2bcde
+g: 2654c54957d5f231ea51f06c3038414d27208d03178238c4113b92a2f28d0e74a82c4389d2fb4f5f15986a24a71f4fbadeb1158c244c7ecc7f68f252616dc209de7a459703c1cd085e99d48f0b9281d2bea916cc153acf6ef383426b0dc590e289046bcc74e8de8a7d9c050dfcad021ccfb9e00725027ad0c7ba202ac82aa36ab9f1be757aa843e5cf012c8e0fc143be56f0afc1ac109763a175fb9c4253879fd40ce26686dcdfe9c623bba02c4f7f4688cf3b82bfabbff2f9b3b8c4bc142d143a5c8cf634f55015c5c7a87a135c8c0c146c84c8ee721a2e4ade5fb84c935ace7be84dddfa744a6ad9412508325c7f965cd8c61fa48c42e29aff127f3e9cb3ddda3617bfc8f0433aa1cdc67df7b73d0d2154a1915e6eb177446678469e3afeb76b90c0fdbfeff7a1ae9c0f5f37f89d053cc394599f48d39ccda33d424776ad9f97e8369669f3396f0cebc496bbd563925d5838292ac5f1a7a4f2d943800c2ec44cf34139d4779dea375e90479aaab0934b574d5f0bfaa369cd47bda3b39b5e43
+h: 200
+m: c13052f7a9b02c725b91f804f703b7b7cd91265fa160b8a6a8d4b96b48d3c973c6f1781738bbc72734436327f08d34b04c523aa4d3daec93235ef68ca742
+p: d64274f0b853957c3c4f76a4e228fcb99f3ba3bdb3b686f0323aaed4f6635319338feed69697c2c6bba0c853a2fbbe648bafd5e3f0f2fdf12d884b7d648d9c2ccb4d030ad3c9dd8388970bbfd832ffda49688c1f146c32c62a1c1f17ff24f5ff4d0eb553212163da141db6d9cf4e006875959b32c09d9f9111cf6782800fd47878f894fc62244bdaeea6dc27d15226554bd100e115a953c511455f5025937c16c9cc32c5a0038d1c250391e09613669a0e8ec94b6539cc6fd2e94c8c78cc5600e5a07f69012811f971943e84016ad5ece193b9d536de197f40fbfc1547328d59163479231015e8c4c4fa7748e9863d76825a0d26d85fdfc006d3134958da16f93dbc5fd01767abd812422039d3d4dbb0e2d7dba0de764b4a6b7345fe03d7c88d0def649532e7465339ed876dd6a06b4657f308f687237a3d102fa415cb2c3da3d3f545374ffc2db2aaa735a4bc2d377d21de36ea5583348a51c8691249ef2418b9e7bdcf765afce97f420d8156306df909d4783aaec74337e5102b261eddc69f
+q: 85866b52ca7abb554cca8e2bd1c7a576360c741619c1c5828543af1854bb091b
+r: 17681cfc288a9af204819850a801bdccdca7851c81f15ebd5e2fe8dda998ba26
+s: 721971a5d0a5df0de7fc7bfa43a876ab9615472ea9d25a24da23ac3e7442b26a
+x: 76313df7999a1daf6addcf77cb5035d85020b88c8b93d144c045d52f9d1723ab
+y: c88d58b26f6f5d15d65b8e88e57b52bbb3f4605acd317dccddf0126d07da1728d8db9158ad6414bf05a21e431b5813e71a6136892ea51c31826c08127d0f03005420601ccf8bcf589eb57a4269b3c4c4b02f2b0c0c6c32bcf009138186045b7e4914c1b2e22d2444a2a0e13fcd6d83200ce27357c458082afdd42a969c5fa241da332252203b239f4be10fbc9bb71a2852717b88de58b52b8c3ad45c7095f258673a07438d320d5296574b76dadf014fed7122b32cc2f2cf9de43851f69da26411feb8d1df3c08ffc22a57d0096c712c59c34ecc5b6d6193d4e10fa14f8fffeba770c2528a2927fb5cf14a8ddecb4bf06084d07a08f67c474641748a33303edb7b6e58426d0cb2f1128b18cf62a5e4de47551034cb9fdee1eb6f43a82f47e2544acc0e7a1f4e33b3c87735bd135d04886f9d28ee1da564ea82e41e664b26da5d1099d2437a122c97e2e5f5d587f2934cdd1049cb0afe713d9c11cbca9dd4359a1f2dc45a8afc6587ba660d33a76655f283d9903cf96318ca2281b181a0410282
+g: 54752997542fea6994ef20f0e6f4fa5480c9870da25b94a8503de5eb76f80a98c0273d626d92486a1337c2dae36678113cbcc243214a3820c8e89c98e3b2449b5c37947dd250967f0bb0c64c4501fb2668c3be02c2f1ab82689cf0ea023956d2fe2c38e99ab58ecd89dfac66cb92c7f30224bd86e42e1c9ea2c0ea79c5f7950225d802e70e62ea01e568a3f556bf8747dce52c762424b2b6aae25f89bc4c907a8534daca7f8858a8645a5319d22e7f6eec116b93c14ca8bc84d8effc25b3cba545249639ef1f53f10de54c9c91b51083b9f87fa6db438f17e846ee0ca140a3c083bf75f002711b1add956b5017131607d2df847b5ed0430038f32887206796fc8bb8428dfacf462644153d76215935f50010255471c771edd5b27e1db1e30a8212d7836061496df4603b54396da056b74173dad52edba35d8073d1f817b042e39f1fd1bdedb7beadd5cae6c115a3df14b780b15a6a840510f197a482486840ea097238c366382b08b5152678c6d4c853710e90895290e4a0641fd28eb7a91902
+h: e0
+m: 45f8963daab81ee0dbb33fd39d5c78531aca9254ad306e604df679159616a7b398d316d859b0edef37a440618217636e782cc9b6982f777cff0c1b9ee9c8886b6615fc1feb6e75b328eda66da5c9918889ad2fb1955da0ed1fbb724d8ee072782bcf1dc265c6eff7099eacd6aaf484b87e7439d78e6550eaec0c53fe69
+p: 9be72f23b783501416b43f3261e247a91f35c6a29c2f7f06128235541888b955d6f0a85215e4af29f572863b9e0b6121a16f43c8a7e8993067c2ec6128c4cb05ddd271a15445e1a35ccddbb33feccd6b36699866681178a72174b918b85551dccdd708056d2d9494fecb401dd97dbe1b5785578902206487c931706475c27891938593a47b06a1b9ed930437ca26a6255be1a0e69df4390df1803f74049bb544a13756598083674db369f4c1c142f928382aaeb0e22687e79564bdec32db27ad33eaa18e93fb3c2ad27fcd9e191c305584406a985f068ce70c7137a10d2ceb644def0185e37d0357ab3b72af631c67d4695bae8e771a0e83833c32abfaad390218163e3a62e42a1180ddf57a43cef697bf7b53880de1f476337b836e4e1427e33985ad9e75748ffa67d9de615c258bf3bd48249ca57fb3a09df28a3ea087dbdc0d098661fd7d933007cb84618f1d42d4e3fe7b13c6498c882d4d24955ed68eca8dc90b785b3b2de4b217462442aec4a5551b1fcdc4c05f2410371f40206ce4b9
+q: c61d00ea045811550ac15b93b7a4d917fee2e7940b2aa6eaae9113cbde6b7179
+r: 4437040a80c38c48e0968937ad630a430c0b548008129012a03fce469cbf79c3
+s: 1496011167df962f46f1030234387793f7380c4490ebc05004d8732536beb62e
+x: f00d7ea6d38ab75ff0abae8ab5344d17283932981a6e840a21f152b2f9e4228
+y: 2ff8c0a5fc1bf27e011d01b6710e03dfd86e5459782786db6c22b8862f12d600eae05b09f7294a27e10672897483649d0066fe0734df883153122e0b07b94162f6585f803d9ddc9c4911012e917d14d221259ca3ba10a71214a0b43f5bac72f7230de5e1e2dee30f52a3a6bf1359c6dc9d3747b7d5256479d5688435ca15ed4cacd07b886b9181604d00be4d7e5d60bc03d3cf16369beb611cb1bde5f75a06eadb3cbe56313e0bb56c829cdf1d1e7b9075cbcfd0ff49df4e3ff7345f8b21535823aa3cf639864a8fbbfa06571e56548ae9a2f3543d2e6a49c25accc8021f5d86903744681c70c859d749462f7d49f2b689fb8ee7b17e6c6dc2c765989d6b86489fbec179cf9d1a88f8f1b4a4078fa8576776cdf7eb77febcbe647e10e475eb18b65b310bc1bc0bd787134e21d1fd08549d47df7533e43f239f3f8337610703168b589a09e895c2b4c1c6122708469cdaff8e2fb094a7ed0283f9dc9245c0e178397238c457b00cb60bb59a313726d6c5f002ad4e110d55d20ab08ce0dc558130
+g: f88b439c1d5a24d56b7da4dc0cd891d5f585a4eba8c04c9c21647feffb099cc4ae8c592aa07bcfaca724440b638696be6da9c63dea938bc57d217cb5601e2902d7058e3f92f228253cfe612abc2657bf78803b22bd7fe5247b2a7fc6fd63f30044794043fc7f09a4880f8b033234a482434ad118f307da0da05d10b7d09c76d80a7180891013b3ce94880ca0aef7dfb89e7ec7c38f5665bdf7a103aa5ea95d04a7ca851aa6c1bcc6d2d5c818ec43b7f1ea1ff3baae84f9253728705ce0b41e2b6490665f0d1718019a323a36fa647b0f60e54e292d457cfe3e53bbd09587adf566fcc602256023d7c4710c8ccd1076a7bfaf052b48774b3a447d3db1a3eabb3911d045202305c1c22b8a7180969c3b6a25bed606b05e010216243999a3550356e3964106be2d140a11616a3b0e93a030e65e38631def3d731df97d6c82744bd70e28d2790662ab8bd6066ba71cdf06375cbf24db30672c646f2404de8f83a6bac9bfda637d20127d690fdda530f843dc5fbc340a52a9e583381cc3733e1b5d8
+h: e0
+m: d8e89814a1c2bad79aff1dcb84cb4f47bfdb17a3f51e450aa6af09ec3cfbbf6c83a81c31b710c20cac01bd724a192492754b1d0527db6441c6b63f6ca174311a3b38a9c91af0a3210a85a15e6bd1f3bed8918efb4646f607dff24a02648aa8fc4d31075ffe0e290275c6b48338d33c55f99f5db6ce411721c7c555c3f05929426a
+p: 9de469e959e408c0ed9e6a48b8966f8926415df7e6ece9c1ddf8dc5347c42f6aced941c4093db833a5192dd093ba5da0d2c3ecc9e6b86c4e8ee0512132277b82365e3c8648abeeaa4b0d833640b5c8639f41786cd237b5a67a43a6c4edee22527c0f35a84ce742fd48bb7028af4d638b0792de8ff89f41a5bedf02d05e5d604415387d48d26892e6fd64c760353e567ac899fbc70c4fc38006a253459ad1cb01f35fc4ed03201a66f24dd3da3a08eb68f69a320ae9f2a58a502cb2f27ced83e4fed0b820adcf1078055d344a9047c4dcf87b1cb6faf5b236db59b522aa954c1bcb5952f41f2393c898e72ceaf7745715b620a332cd0958cd6e5cb6853eebdf21a8957a69cb9bd90ed2fef1a4e14e23b074d20359b31faf2bf4c0b11aea73124ac73eef14901cea349452742f9fb6b9f5538c72d2c7c91908bfc50afd230630a87a76c392246fae232d664648af44565de85fede34fca9b20d50584ae6195b24e8ef554722cb28e782e6fd5d9dea5f3e072454a636099aaddd021a02ef6ad864b
+q: bd64cb7286fb3ab2973b6d62271ae59a9f800784509cc6eeffabb9b5f4d5324b
+r: b64e0bb2174fbec119f7fbf72cb4ef5a8c25c420e153fa3d299bb7886ab308c0
+s: 3489553457d35b244afe5eb151ee27af3de2d3a665d608bb787a105370ef43d
+x: 8073a3ae49cb8c9ed31c9e6e50ebd86d88ef9f3e91cdf3adb55a01d5cc6731b3
+y: 70ad82a27171a57eb752fc53b4913e12dbd19d4c0dcc31ccf24b907e65c5f9515e89d8633396166cb44e83c6b4a94ef6a46bb7e4fe49a6c665947a7063c466c697ad598dea75f9ebe92136becc579c84ffce88a1c826574a987850352199f6b337964709ad5373870e158122b7ec919e84388ede9161a5ade3175161849300033c13880d6179a39040a44f6d3c25b0be4ce7c679c3c4cf4ab1b13444cb0ef2ed74fa427b7a0fc0f284180be14ddff22d0acef1cb480818f74cb398be50757ac8582ce70b71309fa355bd6d905c12c2a0a595886e334701d159dc6830d37689c4925a9bbc8d9f5404dc3b4d50919d2c3cee44598a261a9c71fcb8f866749230b381fe781af56412ba6173db3264adf1cd799e2e2bcef84a32f53786a81b099d37b7598564960f81b344cb9eac67794a643b6727b4c5b756fb14d306d8717d03e3f853dfb6146b611bb76252eeee1c31f7d305388077d85e23476f0fe221a52d26f861ed31ffce03fc4c1a4dd08e682cd7284c4e3c53161b1608c824ad47683056

testdata/ed25519/rfc8032.test

@@ -0,0 +1,20 @@
+r: 9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60
+u: d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a
+m: 
+s: e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b
+r: 4ccd089b28ff96da9db6c346ec114e0f5b8a319f35aba624da8cf6ed4fb8a6fb
+u: 3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c
+m: 72
+s: 92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00
+r: c5aa8df43f9f837bedb7442f31dcb7b166d38535076f094b85ce3a2e0b4458f7
+u: fc51cd8e6218a1a38da47ed00230f0580816ed13ba3303ac5deb911548908025
+m: af82
+s: 6291d657deec24024827e69c3abe01a30ce548a284743a445e3680d7db5ac3ac18ff9b538d16f290ae67f760984dc6594a7c15e9716ed28dc027beceea1ec40a
+r: f5e5767cf153319517630f226876b86c8160cc583bc013744c6bf255f5cc0ee5
+u: 278117fc144c72340f67d0f2316e8386ceffbf2b2428c9c51fef7c597f1d426e
+m: 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
+s: 0aab4c900501b3e24d7cdf4663326a3a87df5e4843b2cbdb67cbf6e460fec350aa5371b1508f9f4528ecea23c436d94b5e8fcd4f681e30a6ac00a9704a188a03
+r: 833fe62409237b9d62ec77587520911e9a759cec1d19755b7da901b96dca3d42
+u: ec172b93ad5e563bf4932c70e1245034c35467ef2efd4d64ebf819683467e2bf
+m: ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f
+s: dc2a4459e7369633a52b1bf277839a00201009a3efbf3ecb69bea2186c26b58909351fc9ac90b3ecfdfbc7c66431e0303dca179c138ac17ad9bef1177331a704

testdata/rsa/encrypt15360.test

@@ -0,0 +1,54 @@
+c: 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
+d: 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
+e: 0
+h: 200
+k: f0
+l: 
+m: 35df7bc3e83407e1e7b88bbc49471bfa1d257d024be63033db42b89d505d5d981f03de2d275db2594c1db7645c51eb3da4595efd6e7d0a4adcfa05bbd6ab3f30ba0ac955da381b8d93c7
+n: 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
+u: 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
+c: 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
+d: 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
+e: 0
+h: 180
+k: f0
+l: 
+m: 11ab9c158e85c2c9ee4c7748853ba0ff107bedaf601c3aa6b4159138e4c08569b2cc0fecbf87f46e
+n: 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
+u: 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
+c: 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
+d: 74e189999170c40995149b64cc31d9e936b4ea60212e8d6d4c5688c3c5df1d19545acb3ff3e9b949f26db69e36ca3b03dce1c3ba6c89eed3a936f55fa3b81b727bfc08e6c38e08433b576078eeefa2e860dc162384048fce3e8aaf8ca8d44a40bb6900c1b4dd5f87fcf5b1c4eac20eeb75a8504dc4d0b7ab18a4c19669e792321d5e6bf5d9eff509a997a2dcb697e25613ca82d5c2d1c005f8afbc9e8ffa3fb076e111088f18eb72a58aa32c70e6c8fc07661eefafac494f45328e09c6aa231401abdd7c02e01af8775fde6eee5a849976ca9140fee66dcadfdaa2e91075eec5510cc5209f0866db0f3b6429fa18bdc634c1b6af6b2ed8899fc771e6fd1d1a9bded16c39a17d0ac0bd9a134fbc809ee7ead5f66872cd06bef1b6b6f7ed9e19d6514b42c51b3cb8905855ad41f1ed710d3a8515c66138e2180d36cc6efe815a0a9251c37c78a8a318619fa8d639bced0a91c71cbe006e74344155be33bb84916040c2b8cad4ebfd256efc01deb1252edfcb648e0522d12ed66a4cb56e0c63cd1e855b38698e095cc60efa16215885ecf0247a0ba908f51801aba7ee7e3a58be5130f6e25ffd58e852df9e86becdb3c1ac8525965dea22b231943a5c8f18284646a0f6cee4e68bc78175bce3bd8dc3f241a59e2396c2039e161571208b494576b40b6e9e239d174542f7c5fc246c75efe1a89513f63ad85885cd8be6f06f72f5b452a2b296076126a8fe3e55dca9833e610bf0ada3260684d05fa36c20b7f45c6e868df408f4c1234598ba67d9e7b94315cdde9ce9c39f97365f56c5d232e5bba454e26854033f1f64e56d30a23738d42ddb966176b4aeea3f6273073422062b0fcc57a5d0e1ef85698b75e1ba17aaca165ceb87c18d13bc1a0c2bc06cabbca147598909981ac5c1f79506c759515f75af9ae9f653e1f412a737adb92649bdbb5222a67d049169165c693c668dee326ca9750872b17d0c5f8122f01f30c1cf5b7981ef200626dd78503a7e4f0ef799f164d4d91702ebed3d6a22f036b3ad1e541536a39384a53282ecd3c1c7e4bcc77cd72f408dde0d101cf1c9314da57860a204e6e6b14d380b59fe9e70a664516ad45d9b5d5567b786042e57f54b2224886fd2286238217fa67f2f9b7bd1ff1688c4afe759144b2a302f194df6042fd82e7cc7f2588a16a7eea96f4b05347cb0ff6ae05076710edae6f30ba7a00f5661abf98d6f0c5acc047a916976365be8f6db4f1401f68a0a4e24d22724f998b1c9beedfc0ee5ef806c7c96730d1937e3522d0e6048bc3baaca2870afca604079479771715d5ec7f4ad3dc5c979edb608e3460b97e5b24a0f1f3d6f66f31b2da984f496ae4ac5e378c34ed06e460324ddace423e657a2f5a5be225d2ea0f7b02572806b0791a778bf37451bfceedc1807b52e808c1cb6038b8637793b527a6b1b9316760feb9b49c1a52433a63ce22e30e9124d967b11c481239ff2aebe224d1ca4087cc6b5f0e998db4107a49fee8265c73b443a9403080ed2aaf4d2f5e8ec914ffce0954a7dece34c0805e5b46a76064a7005ac4bb0f3bec643c488e55b13fd81a97e07c9f01ff62f95af3a1e97b957e619c178eab56d3c2b7c554c6b496ee0cf48e5f4b2ccefed4a72c0a73406d8d258905f9558d740cea49f69edc82eb8077dd0be6100094679bd81139b492ae0a66ed8bba4579e2fc768e0862468cf9bce591c12d806e1cf55012491f10feae7384699bf00b9b0bb8153c375f865ef76856f4e5ae5dfa6d59703214e1a4c244f46e6132afa250c7563751638761b22af59be9364146e2d91482f3c5c22a5cfb683007e3e4f3cfa84d4adc07809cd2a1451e71a5757fdf9e2b65add5adfba08e8e9f881fe55a0d30beefe362cbfc7f899b26883bbff56df61fe443f80a5697f667bfb4a896a9089a975b0fac5e0527d8c3aae613b8a06e586470c320cd49e9891f69f0db7238a78745d6a1fb434d2b8c612fffb4a164c446d8ffe79f3d0f5a600a46ba36c982751dd975982f6df092988f5a079707502b89162f44b3499cdfc118c7fb51d0b6357f834bc4b8c2dad5e0e02e77930b3371c8d5dcc993f5c0a9f62a5c3bba87866c0777ba4c5a6f8493c646b3c258ccf5b092a5a935b2fdc8455484259b68f845e12d13c2571ce9b40e6152d956987027099c1dc324e5fa3629195dc9e1b4a5a9b1cb2b770d63a99ec15b7706838b2afebdfed9c2845ceee56cc29d023471fdc402ecf66a2fa4072e13c3f9a55426d975fb96cb301197e14fd0b62000897a2eabdcfbb885aeb33420aef9de256e1b4639f8de09ab74b78fae27ab201e1a62d2d60c173f5da0e5a6aec3ca30fe389616214610599e841621d16430cd29e86a20261bdf8e2a3019d2e599e676fa9b8808eee06bbd5ba1bdd81657a1069c24422d2151bd17145169928484db35ae6b75fa52b836e70d07d32c3ca4b1b183bd97775d7cc23287a6f4dbdbd124119189253c8843f74eb7fff0009008d31adecdf21b0614ec0f2ffce3a6ea91d88b326a3b4730fecd736f49ba9e554f42805042a5a47c110dc00f0b081fd21a460fc49cc5979e51d18820ae4e53c7d768130c2d9b899563928d383e238d4621f036a1300cca082e518b2d93fbf080231a6ec1dae9f3bc7e6be1ea7f72587616739a1c9e36730fd6697acada89e3664c6040f19bd236836c1f98562d5bf03f43af11193579051
+e: 0
+h: 100
+k: f0
+l: 
+m: 5974d012a9617041
+n: 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
+u: 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
+c: 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
+d: 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
+e: 1
+h: 100
+k: f0
+l: 7439346b5450783f74614e6f38653a304e277c3c44656a5f327b312925447c6b2c4c3f34565472687c42315c655a356941675073382d597d3a583d247955556b415245466124484a417e67756559616f72253376324f5d795f647539264a432d595d4a
+m: ac324bfe4f4522ce95bc3c7114d790455742804762ae2d5ca2536e8ab8cccbe350f0cf199f9ebfb697bfddcc5faa18d92c9f3e4fc82ff4a5af5ffa1b5d9ad77c588808d5447d21908b5d00b8c3ec685c57c124ddb61a7e81d82b9d63eda3621af7
+n: e3cd8ad0d991d42ea259493dd2c4544a1304bb3d250883396aacbb63b823e4259c0d08f780506e931f177323ec8a6886b86b9dcdd012d31b5a721cfee91542d5f5bb51f1585affd4e69fe3672a02745a03c84f409a40dbe91fac1f870a089671d2d4e2fa5f60261bc077f5ad5de684332a8eab46e2077984b0f6ad194716e640e84a757ba7d5ea604349ee6518e6a45c298516027361b2260aa206817fca027c3f097f92ba45fa4e0832999f5c6b1033d81ee330c8f8df088ac1ff1342c4954066c3115d365f999ca7584e4a0f9745d0960f7d746d19efaf521ef130c7318145de21690fd3c045a24a061a2d4d7068d2d380c33427dc4a578d34ae544e81b1d5ed3449b53e886cd1df70102c6016fc344677348d4f7a9aa7a4c42f1d7e2aa4e3b59a797030f09029b875fd13032c7dbc8671f22fe5f40ec8353220772a07e4bb153e2907d58938c09d3f437922a96eaaeaf6aa66b78ea227d6e28456dc1be0198265f6270990fd5bbb7a5f206b47eeced8e100e58b7cfd06681bf887e8cd2fe6f573665c9c0887541d5babc14a0b1181c04a6d2d14acf9b85d94fcdcb778098397a01e83c53c42cf439d3369c567006e3bd5f9f2a2126216718de6bbcd08efdc2470f77eab1a843f4062aa2941739b583190d77207f3ea28dbc00feb035b687957cbf3e544da4517f6b066ea59b70c7b3c9e5ede4997ee15d92bfe425324dec5f33bf070358da80a3796594632c8637d0625b435a276e0b1a7f3c15645783aa46bb4e808e585b3a742cbba65cb673345d31ddff3e076d6371f045dde92b9fb68d393525379e72bbc24f8c39add189f87a2f4f43504a0f2216f3565b755c7791c90a10ea960b785ed332bafb7efafa3521bbc2994578b4c4f5b45ea0e6733a187a14894b087758cba5d6c70f9a7107bb14665577f05be6ad1a410bba1210ec6eb3a3738cdc8fc9e4775ea18e653a51a553e5df94c798c7123defa317ebbdfb7dde113e1fbe16dbac377807c998a16b1518faa0c17737948346a84f1ea0c19b773a74320b83841e8608acb1c66932e1518400c601b645b2b7037c1531c2e10e8288952b53ddf10b27608c196d0d6b70b9e0993d7e8aa775bd610a072a0c8ec4fd683372a9e72d5bd25135eb950ca289ed8fe21f3b39bc15b0f686b8f3ee9c391b0a95f13883b68d7670f3e1b3229278d07a6ad47c70d9b19c289403ad7a08c237b5780e953321a35b952276ff23bb39fb91571e5f09a1d6b1e70ba2c2315a393580e94da0944c4c40caf962d4c907f7b2c0d619cdbc67f47ffd1b67e8044437b7753b0ba1149b490779da89c46f5ca54475b32f5980f326ea736e4a68a5982a4c76aac3ad1174b46567c0a4770af04ceff89db392af155caf742ba8e0b04347bf1b7410d13e4c9375d21537f907c0722360117720bc01c620fa89bd43fb3559e84801c1cb0d7020b8b0b810714847341a992d89a482b8645eb5f6e7478c35431f9a20910819d0fc948b523af3dd024cc9335a6bb075cb9d8db72d424d324f9bcaa633d8cb6fef7b42e38678ca11dcebdcc9e29e2b0aa7f99ad09a183e98531fd92070a8b5d874066d4ed1508194e552ae5209f2abf254199e848705c786593a6b5a936a1784823b509c0fabce621cdc8881d92b4218eb1a8312bd161fb4303faf371b946d2ca7c40300d73bbd1c946e60167ca9e257a544ee1a626388264f3e0f4ca245d952891c4d0e39839a1067e51c705dc2f575147a03e6cfe1f2fd6773956e0d34a33d282003e8148ee775be2b635bbb3a090bba247cc8ce30833fc7238f05c78c0cca25b15e9d124c229fcd5773d18db741884438d836b7654c8bef0c00f3f84cec10bda2820d14e89e769126ce5fc324bc62e34f268fafd87055e2131279f2f201cfbef58c77cdcf8683bb17c5e4e4d762eec67e64aaeb217ba73184d475c4473c239afdd77059b83063a2311aabbdfdfeba0b91fd4fc051e629ee464a6259b578c53d1fc51ad487de099d1e9f91f5876816ddce6b89aa8872915fc10e2fcecaf4daede65e6e0f85b057523bee752ccfe406afab0c4b0114eb4f9b19999a4aacd0a3be414f8f9717262e0f0e7d84fbf042ce00ed2c5acaa39c320cb1e7143d42e05bf001463665e357787301ef947eb2c1835014d3b727c836c31b0bc472c753c165e261f253b33ee90f24d318f3cc7aa41ac5f2c69407cd0627c483b0e33d6d4e664b6553c80112697b29d9bbdf49723ed83fe2199d6d88b0c1babe85acb6c23fb41dbb4f7cef6ce9e9dcf4751609fd99e98ccd0cacf73527444ddf509fecc81811cbad3918c637121db87e3a32e50aec190076375ddf5840b870311f205bea73ca6f133decf873797325e0bf9c2258d50f3a69a512f1023de23726bed2e3f53fcee5b5a74410d56764bfe4e3b7cdfe62d0a399208bd0622dc611806ee9e862c07fa6185e16c2ff07927b2e069b82c116381e97d3d6dd7e059e721398f57f7d20c31a572870b20314c6ae50f14bcce8946f62cc3b7cc3a34c1bf75c784c6d8cd35f8ff62cea82a4c4c50fe0f379519596cdee658138f1770ba388e0332a7018ebfc146cbf91f8e3032d89c3ee99a27b373d37f9866582a215d1d34bbafbd0cf7c987fb66f0653b4cc0dba692e8e81093b6fae8d909aa5e79c5c605e3150d06eb30bbbfda55df0fb30f4fe6d3aa882a4c63c2722b45d7255425428ee5b5
+u: 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
+c: 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
+d: 1ede88dcf1ddf9ec35b108e55f0f19d860da23442493d1b851f1bdf8b42457977e9eee9510bfb2c739a116f21f73d79be219abcf3f6dd19cdcc06b6819c3f49a8cd0364af5544ed480e7805d7b5ed73c3b37e9476ce2777a5dce05fbc41df0bdac2f707d439ecfd4371bee99cf40acc1045f5eb300ef796c7f51a0042290ea4265ca89c6d6752e7d99471cb0cf52dec0dcae716027cc71431fd2dd2ac947215397c21ae63c032e00cc0d8a944c015d9a1856ca6cdef69dc958a3e94492b6b7397fe3b561a69384cfaa629584f678c089a6d1dce8b37fab348d9820ff07d4d2ca0b90bf6b278058e9d544b64e597e0b85ec69f9b51349072ce0eea9d9f4169c5823011e5514e7efb194c097ae69f7de60780b3ca3857d4e4eb267c639069ed34f7dfa3d65ffd02ac8ca6239999b1eace36f741fd027203a0fc9432687eae718258ce94a4c3a2f86e1bcc14e29bc4dc40d0923f11ca2c85ef03ca5fde5ec31756a378193df68709498e93b00afaadfd5ec4421f19c1c32ae4b238a24cfbd4b0115b6173bc00572b39ef133c939a9e40e86a71e37a056a8c913292a6d98ce41dafbcd03183fd86cf9b53eec715323122def38572c8f3f6d8fbdce47ad4b776a379a40a96b6d5ab720873fabe1b65c4bfb6ab4e91d5b5f0da22679370500d5fc4e70c4a6f1090a09eeb1246cb5931657d3d7e61bbb06696c6e24bc9548914dd966e541f5b506d8c32d2af14b0a8ff3a4ddcd663bb11c0f53e92841db386a09d2a52798c421c921c31d46fa84fa79f004d2af403ae9b62a187cf7443f6b9c7a4132cc7eb817ebe6b87d91053b700ba229e2f64fcf9d7c45ee546bc19def06baebc30d0890c30e8d66bcc93b49bf1795a96b6238027a3a81ce8260765536d5d86a1ca60ac296aa57d091f83ca7e0ba6ce695ec58cce689a9c0191738d5e73f07d15ceade3e1d717e0795c3566353347c4b7a2601ab02b7f99b08501357182f6ff4408557b61d78c074e05068468ad660b43bc98d6813001b46f7fb79e06d024c9293bc5290906a0ee1b7a3592d34cf5fedd53ffd8dddfd1c6548600b0f566910263ccb25cb9b16828b72588a626dbe16f1f46bd88757a795a62bfb345432a36517ee4a3cdd245c2342592834b48030c9e9adcca97cc678d9af4c61bc387b09d30046f50a3e1dc7c97474d4334dc791f8a1847a4ca210f592bc1d5fb34235ae58c278d5f7ede20677bc4fb1e84ba82c11a4eac0b245cbcf6a5efe6fa99853a559109d761940f9df9c77012eaffbecdc393e6c4378b3299cc9b58551aa1ddd7ba0c45eb648a6d2167abf537d0117bf96adfd4e385b79374fa12d575c154620f251ce2ff1078b6bd4200dc4db08ea44f97a1121747786bfe8f86ece93f08af8c0943a06ad09c6b97a228840b34ca6566bcc113b38e84edd99c92929a411a1b32d58063627dfaa27d6ec535beccd42b1e6cad681d48b42d8b76564b5f94dc52f938a11d68256971f1d44c0efdb8cc740a8376c96d2d41bef65149860f3d80006e40444c75174fe79a01bf55f06004bba7aef72abfd2ee7f1e16b5d587cc9b4c50a903d754edf4783f38940c00db97db14306b18df49b37950d778d6a1155bd8517e998f4a39aabf9fc18b1c64fac04e0b14e426bbdaae2a210f7d4d9c802e612ddf882598a7ac2f520899a9c50b118082de33cdc2a265704895d42e951a050a49f2fc6c969dab1e8597c8b4f255db7533e6ae34ec626c21cdeaef505183b8e74b4b86f155435b1b679c8f57e955b5b50afdb49f0f21a69de82f927a99bdc04f5c4979e673e84ecf9da7448c11ecc5b96baa4b5b836563637f50052047ae5f18b623db3d4d8c9a8e02cdf2e9ca3024be3871ee3b11dac7f191849727c3d0f5540e1ffc64419c44ae1f1bdc579745cb819e8fd612996e435a01848a2ae0373b13e860a307b2bf7a6c08b725f8dcde495a60cbfb783efe09127530ab32d25b22a1da2b2743cc9b6598bc95fe61c3b447309bf395c4fdd65ca614a7c8a1e6a77609ccfa400b001f36f58bf96a05601062b17972721f528c451951d7d7ebe57520c9ee63b6e2cbeb9e0241b29e0cb84d415474e1c4179283b73d399d5e2bc1e719f0c1a39de4446d3716a649417798877afc55a85f62d541ab57fcdb609fb45248a0c895c1d6ed7445495cfdd5a316316515d87a8e3582989740ba6599c860202bbb758a94da3597c4b9c6560a8399256d404a8c6ffb7fdeaa029893cc953070a4848237ef9085852f441a5b9fc47805b40fd27487ea270c536769284f2574087f962600bb34030681844acc1ae2dd38393f429ba5173e4e61964de469f9211e37528f564fbf7be213431767a1b90ba302db5c4157bdbdc6ce0bc3f269b7fb0964caf79f2bf285535ff7e19352563ca59c84bd45e1dee2ab3b97338f9d38358a86ed05f47c0bf1bcaa3b9326f2bf30a99904c3b1b179808a766456588a7a5faaab51e36d8caad8df0845a5dd1996024182cae89a76774a75b3468ed3caefc84a8699ecf658ea5a45cb01850e9135352103e86fdcd81c45ac9794f1ac28f845b6259889f361a073d9b5be2d70eaf1b566640d85af99db5ca972849bfb00eeae937335beaf9d91b87dfc53ef0313cf3bc808824e484f221265c64ab9fe803f2e28a588ab919fcdb2524f07c1b1e341c46e6bedcbe99f3289800d5548ceb59afba040d987fe14c9575
+e: 0
+h: e0
+k: f0
+l: 
+m: b15c6b0d56b5c04dc52f2d3e100c986d3305213b0f1b25daaddbaa6a9ed29f6c15d4db741e8075c0d3158aa306ef37c0a3363a068ad6cc4407a00f181023c85f61a1204d176b62a2089dd0256dcd719f37b1902ffae4711ade034539fe00ba6c6764b0a8a67b39c4fc449028e82f2ee65059716629ea356241fbe6331ebac0e1
+n: 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
+u: 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
+c: 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
+d: 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
+e: 1
+h: 200
+k: f0
+l: 286441575e473835353a314a672369397c734f6f24655949487934292a3b6a5838663f397452356f5e553e22237d78286f6f66384f66536f717d644c7a253c676433394166253a406e553b3f27356b6e4a68204222724835207071633a5c302d633c70667c476d705569475834693660
+m: c6b7d79a22423dd15c977198f95ee48de52bfc446b3c8f8ce48aead4b5f8f57775c65a
+n: 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
+u: 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

testdata/rsa/encrypt2048.test

@@ -0,0 +1,909 @@
+c: b3638f5c2984bc74a4f9d1bf1570cfa80911d8739df39a671bb2ad15f780d73ae2f94f84efaf571d1b72421e9a568a75ddc65ef152480a793930e189016bfcdac9454df6379aba047074ed83000b98e31198bba54cae50a7f8a14cfd1140a31353c638df887ebc4721e2cad168e619a156446d42ba1212348491f9ccd7d045354feaabe70811c30280bc349e99639eb5792076b95c030b63d59761db10db243b0cd00d2b857db5e659e305a307a9131ec021a399d9824d1d307c6326ccff2a42157c3b772c928cb844ec8199876563fdb5c8b521ccdaddc6d4fbeca0b716467e227492820f6fae406280299121f9a6876a9ea774a5e6ba6c04eb6a9ca8928a77
+d: 39ac289e98312af5f68ecf349353f8f733f24b77e96cbc8fabef144f9b7f12fe47d1008b998e3b4c823c9e34fdcb0bf3fb8c9bed8cf7353fa8abca3636868ada8163c3bb4ca8668a44bce4cf016fe307520255ec1b07ecf3a930af50c7e389c328b4a6fecbf6aea7e173782f1f51212b5897b9ebb4c173ea908321c1e67e99d026f3ac12571156bf8087f4e24eaacc8e26336309d07b7ae1aa069f72c9da5a872d12778d0b7e2cf0e5ac2c51e50141f16a9c9051170e8f5cd703caa3a177a7bb6de48f41ea719cfcfc532ecd76f8b7d5091d6a73e8c845ba940147e45ed451da6408135dc4faf8872a045d1fac1a386fca7c601a2d5212a5158733a1ff522dd1
+e: 0
+h: 200
+k: 20
+l: 
+m: 35a1152db2f819b1b8fae8753b7d441681c8b545f90cf56bdb6ffacd9999bcb1015a1b6856acaf01a973acfce0051040a79ce3d9372acb316793edb1d437b3956d6b6158453df610a909656a2111fffb7809087802f53d1f03314b8bd84fb37b868a9eb69714eb91235196d4073490
+n: bb9166e662dc33ab4ef737eda2fcd7255950e7a61e03e9a560172ce46abf957491fc790d5a70301b68d5f1421ff044e505dd35a6c0a103a836b8e18c60758140807114a1dadff67afde4a7b15063dc2a16cfea070cd81f252947ab8fd696b781b3b2664fcb387a3eeff8ce0ad7cb764b348504ae3b7ec857f7f116bd9fd6219b1a100fa2342a92b6b9bc7be1b445d8b99b387f01d296319d5035d80a0369f41750072b06c5ce74fa0424292004124da6418937b8333bada22c027ee18407f8af4d6f01615e03c6a1f11978d1798290c2c8b3653d51251b8bcb6b8d80cc352407045cf25571170174805194227c3e58d144d0221f287cdc6184fecb8939117f41
+u: 15d660eb835a213ce5205fa16adef15e0ed93abc0e3edcf0142d10db0ccc60ea8ec030237440f330c9cee3fbe34e1da796cef0d5a1cac27514c4228bbc33bcfcc3ee531b4c34759e3cb5d0e9e9703347e5bb4d3b4ddcba77a3c93cf5ee004244e86489763643b6b25c5e1bfc0eaa6cea0691529fb97914fbc8d809be33c0dabb2e7e24eaad5517a0a0c8bfbc8a5547bfa94748bb71a58da6140c0019daf65016a7afb5efb1160a288cf3ad89e27390af4293663587c8a7b2c532391015c3eb512e19b7a3bc72af3f27441ddbd4137e691527acd4516ff60f67e2d1d2bebe7f1b0b195d86318489b48c97f06ddc19d2a10bc9b92779d870c116310e082456833aa
+c: a528ca32bf07f649899f32be0d7da03b5cf41552e0a864638606149360dbb120642364635a000c82e8704e2addc5d10f48e363687881b21d9c8a6e680375e733380ef44bfc01ee96f8e440f8136c72cb2ba1633ad93a34e8cd1aafc9e3c444704ef97cd4bc6a55ae14adcc2da0dbfd5db2be410c4a5620d1a677fb78c060fd78cd9b376c8402aadb3a89f9d9f8097cb8638e8cdde5b5bea6075ae21cccaf824ff2f01c60702fcba72bf7d0d55581d0fdbaa88e248491bacba698381edb4c9e7736b6f45bf6bd46b370121e8b3e7cb23c925a9ce594cacf3e1721932ad4acc8fc64be8c3ddf885a1d159451019ca7c97b79976e13e30ffbc1b6de38f47e6eb6bc
+d: 4ac7c7256247dc9288cef117e5049a693ab65575e3d08b4d5387b311d94671ca035099c9e63969f5b25f9ec1f87dd586a9059bf8da2992c3476d1bdfa311fa6e925ed8eb28f80f025e516862eb579335cfd6508de4f69f97ad778b10c8bfd440b7405e7c53bc10bde7b75ec6bf37ac8fc831975d9aee249e735b33243174eb75dcef77589436a5901073ee5368e4e6f8562dec6a299a42e920607fd40e76704fe8dcaaa38cf2b43857899f82e6dda9fd6a595f7d8e23427671120080dcecfc040584125bd6917c570d2d1847a7c773a27591b15ea3a00dfdad7a9f8e4e83329b18b6614da4a059c8a9191a5772b82032110c1613e874217931dc8f314c40fe41
+e: 0
+h: 200
+k: 20
+l: 
+m: 55ddd137ead1c8ea5fc25b2988365b1ffb794be5fccd501cbff468923d77b899f88d69fffffe407a6de4dce1870a943a625261217b66e9b4008778da48307f12dc3744e940efc81fc558e8e75fbd5dbcd8bb173270a042f167f5a4d3d4cacd64c1c63c689acdd597b259204fd1fedf801643f71cd9c9244bf7
+n: d57d804d8b0270cb1c8537ca5c79dc3371c9aba6884d3fe5efbad7ea5e91fd0f9ff20cdfed7afbd774b4f05c54099ceee638598dc8fb5f05c75a74910ce8d231d5c5de7a5569f10a01bcb7d4539f18e7fda321e75965fa5c4dc93a7bc856536bdab878394cdcc406848ab610a921e61f30532486342492a14c8500650aac6aa62b6fd218d73b7c0b6b092e2f6041b0a7bc30c901a9146b444170be6e4720b57d2657e2e46dc12adeaef596bfb198e3df91b2bfadbf97f4f8298778c242a96a18ba510085c0edc7dd6d74f1a4c0039f04a1fbd47282728a13b55d6c3909ef72bbfa4dbe19aeb00e7a5185a783c3eb1a3ba87c8bacfa4e0de6ad103dd9ad3fd843
+u: 132f9669b4d1d6f1bb208477a86edd41900ecaab4cf8f8b5256052e5c129c427589f2123f37fc2cbb0617ec7d3b52141d5a4f37bd2cc379b09036afaab87b0b46737318d54da0f1d9c4b0a2facb4bd6f4e467d5da795d6a3bf2a0b4379ab086abfda79a308378a4041025930b33569de01f6a7625436057181de8a7ef2ec8cb2cfbfcdd747bfc08e5940f795bb25cbafb44af6abfc8f39d4a501146c3f6e1fb3fcbeb284615bb29ebefff767b9686b8640fc2fe694c56785509b6e3ef87df18c9b93e86e5f0fa22b37a0bb0138a97039b13a97336bfb3d0fc1eb7a84093917dabd1d85c5004f88813a31aea4fd41619e501cb56a2a06f1c107b0986aff8c6fbf4
+c: 3a37987ccfb4f154d1ff5b8265bae1057785162eeae52f789bcb769f133c52844ffea4d8f251b7cd5839bfdf4e878889abe1cd2fc745734e4f884cc0bd0e60329323df075ae9b983675144b9a6d7a722054e4f8d0280e4467d8b8aa53ee87b2f319e58a7b35970faf1f43a7ad035564521c8371fb6dacb487d8186015d3e586d52e8f3ee4ddd4a9f28726dbe48873080b948d172a5e7257cf9785c7c68c7c2693d381199a38f8417eb4e8c1135d49296114f55118610ed5eab5fc5007c6ca8eeb9d71d4978c894dc51947612342314e3793e796fa5f0cb8699d3b36259b7d5030d3290541f564bbe6c712bd0d97e9c52f55c94b852094d8ed009732263af6ad1
+d: 64b3b700340ed9dca01e0e8e337b6bc78ee25fb64a92d5b530467e91c82620d11b2af220e99e1009c78d9eb28fcea21293db75bc586572c51ae0b8801830b3a4326a248419f461519db207430a9b6ee72aada6b1fd462cbd74bc7a625e709afcc08bd3b2fbb23889460b88bab470a084dec5b03eaf8a712b3d523c033fa83d3861bcabd9448c0f87b0b2e3f2ab5ed7685a062068a0976642c6c5e8bc9119cde913772513b59133f65e512011b0d70b69693bb30e21786a54145b748259bbaa0f769bbec995f7f2d7ab0a3b2e778d4e4d2e17abb8a7080b3665ea924aae01fe2bfa39fcba16d9ee748a70d094e484b5b3d58d7b60c0e5f0d6117e5bf69746be21
+e: 0
+h: 100
+k: 20
+l: 
+m: 394a8ae84a1434a714a3c668a5717e1317bdc9344d2d6425cd9d57839b4d6cba3c394ff000653226a7776978d39b6deec73405c4878d
+n: a3108025eb8354681324f66188ee9500b192c7b759baeafb432716ba6bc4acfa12bc4f3dc3967b13280dc0a919e8c5e920ab7fbfb95f181bdddafe5def03fa3cb26fa88c9cbdda4d3ff3af3f1e4e9b4660be2b6d34579430dd7edf289813a47860daedf595bb4594938f39fc12b7e7b204b5a0dbcfe9080650ceb75392a58942c26554d0448b1c144fa2dfdd0f24567b283f864995dd9ac241df6070b56b66cff99306bb508799beb5e72728ff85616f98665f46ac85998c4155cd6d83c4e1850ecd56b31a76d46022a7349c6f81550c97fb7c593f379fcb698078dd346b92955988b1cf0a1593d41ab5b8ee394729ecdaaf41b7793954e1128869ccabb44a17
+u: 191e7054df0d71b202d1b9657a2f6fac51120d7617c57da92050fe65698da684ffa9c5541f2b40888c613f588cbffd0430ae287367743c68b4d35700c1f9c72ea469825ea3f9c82dec791e563d343d9aa7faabaea06f681e9d30fd10de7d3c6704a9001588bcaba4919d4e282a43a97d48a5def05c5b56ccf4ea12ac8b9305606f1cc5290a4952f718f49c3efa973485b4087b49f3bd1662162e7bab63107ab07cff8c5c848c5ac0851a0bf3577e3b40d9725f228d17f29a10171822bf31c7ba62a1cab5d88eb97074ed2b47dade73577c289caf367865f5433e7f5902412f935ae6db7214179f882a144a503053ce3c8bf78dc7bd5a4979bac18c488ffe2c01a
+c: 1a765659c6c42ad71da8c2124ede2c4de7be87c16a81b1c0b85b9712fb28929395422e387726c0e07aec88054dd694ec7f8baf35ab804880ebf1f058a5c3fa76807877821f8797a4fdc94a1c67503e360830e175e26175bb6b8cabfac384708c474f3d6d28cee3c1ace175b0a32fc0e1523b7c7d829ace96707462edf763bab26a0b0c8d63ab8b5e1a1943843b4b8c0f9b9a1025e8c5cd53ca1505cfd1ae1ad11b21bb9bc4d59583a1d1c9af026e0ce886642936c9da7af5634c77d51bf67a2f63fd77ea45f1b65d1bf60be757e77308fe7f8dab59d229f1218f63ca5fe4001790d984dbbfacb4139cd6f0356ec3991c366966780b8f9b153ab152275edb3876
+d: c3f1b6340ceb98936b872f69c39bc59f912eb8d2f5df27a184cd0bf4bb6695cd804bfc24d2cff4e41a3c894a81fad864c677930ace3a14b0cb38c95a2f2fd31fff94f7ff7e9df693aa73224acdf7c35906e1e2553e8d37583816a37a67c0e2f226d07467d0b55b2cabde5c8307e7428d4b97f2e95e241eb4ec4afb30736e12b8aad2f11ee07d8f3d8443b001b3e3d67ef75413e3463a555994218d0fbc6a28decc3877e2cbb81fec420a0ee95049716d27ebfccb2ac08954355a6f39b8c62ca4504e80751d2511ead6d33099d112ed65a51e263a2cc617d2127f645909f49705ba53df0eaff8a7904ea6615e210d4483b2f904c78ea11859f7791e98406e8c05
+e: 1
+h: e0
+k: 20
+l: 6b552e793234224d5963744e35622b65315e3e4f6f282f3b2a236d3c5a6525374539587079485b2d657d6a75282c456f7a5b29417e3f506d2961777a5a26714c3c485d36393a2f344a2d3b265d60592d2b
+m: 339279567843da30f253de9f15433c0fb495db6bb6519e5aff5d69f1db8988e6f1c4734adea26ba56134bb2716d593f285512544492659473170130dea09fea757b495ec3eda7b67
+n: eb96306dcca5a936c6836965e2a77dcaba1cf7c665768f62eee71df060631eb853ddffe6857c9e973b50933d4316086c76e0f56e162980992464180a85cb0b4680873806c1a473dc37bb6a8c6f64c274d96c39fce9f3c5181d1cddff6c655ccfd628438e29a9c817e422cfe1bce5ee98f4944ebce33db8670930c7a28d7100a7860272ac597028f646206b8fbe6f2f57838d91e4782b92506852d827af66bcec1d025a1fd80856ca9a7da16aed227d59207cd1da7133e1d58fe773ff1acbf20b9d5b0a6bf715712c209f83111d7455bc2c2cc089f7ff2dd142685c81453413efcc340241b3719e3d23e14b4b2eb1ffbde3636022822be6df9da8f27792966c49
+u: 1162e9f1c03d6276316855a92ef8eb26732d1edba5f1b62f918c3121cdfefa88bdd6129ebb039fd367edb32fd80cdad7fb9b9710dc0100d47149425837dc82ed2515962e3944e3158d3279ddcfc6198736214fe8808460467a98178c3c5ab9a6573213c2f0eedcac146a50815983eadc6a87ba42e826242ef356726ee0062bfc47fdb5520d973b9102e3c614c1bc11f0247c3e22cc730fad53724d476a5551acd392e10fa24a115e01a63264a9c328d0250f7f986dc996e207a98cbc1a72d845df77da0bb9c67a40357b3254dc083c17ae7a0dd025917d95427c6325e39527d03426a2e031164c830d411bb72e3eb279f689fa2ef584654f74fc68033e060ef3c
+c: 20a3908fe43cfa1de1c90c23813d51a94f1fd3f695fe6cc8f523850deaa5661ca5274756cb91987e86fb96f0af71f12999803ea3d790f99e58a5d82f46bfeff459b7768d7181cafece05d3c2fe354bdb1ce4ac3adb8fef665a61fb713c83e54eb4c69cee72315353b1d3cab80e0f970910f56387ad8d1d7af0afff370fb67ba245bdd4648f171a7065553672c14978e436a6422831a43e56ea45b6b82d8c118be8a01bf623a3ebf662cf390950d137c831ff907c49d884abe4df93e610858ce1eb714fe133a2099a0687f05eb3f91e6f0e89aabe5d4d1791b8a0b6402831f7a5f7a356a109bf3764b7034663070b05b98404b0ea973b0b110b8b0169039337dc
+d: eb5c8af0a813362103bf82761eef4a3574c369e2343aaaf1d015a1db0cf4abe529c07b58201bb5768e7ee8208522bca8799b4577d450abd785f1c38f901b84733524c76e6a62fd62f665b72112e9a28c816c8f11f467aa79a3b8dc41b6821c23a2f6ff404f13c39139d0c9dbffa739d89a537a5b8e61d21d6ac8e2f4e65c19807765a218f18980113564f1b229e62d7616e8e38c53e8bac8cca46794f27cf614be6b9319ec97c3328a3fd65c4702acd90ce9a18a6be9bfa2ac09d2cfcb47141498cc6b08321ab4574a6ffd0fc5c366709f60677e2150bf202c3c39b8dbcdc13d148fa7c4a0488a7d5c92c35ceabc25f7bc1e7585a6500c4ae4e62d1b1da8e001
+e: 1
+h: e0
+k: 20
+l: 78312c504d5663547348675a3833242c5f4a697727584f653a266e39714f54524425744f6c4f633d2d34712258644949445e3d552b794e38664d236333733f6750747d4d53776270
+m: 2ba01cde129eea699adb2b074527
+n: ef19ddc444142eeff9c7a4c8c477463db5d01f2226b7be250f448400b196111e4ee129bf99db429cb6d0b985835083daa0c6da7d0e008230f59fc8a3e337f4603a8204a5c8f53cb8d72542910e43c488450d4594d6d4f2abfe2b2cad47e36026587c94897424a539e4f5db192e3c2a28760425441921e81fbbd5a44f05669a47967d3f65bc7ef6b2fa2f8be16eee21299fece1d5b9a8355b97f226b571421cc43396b4a39fa435d44ac72b085e4f63710eb250a01b68b67bbf016d85f1f1fd3202bf92e03a7d6489118797858acc6640b230ed2c4595a8a1b3acadbf88b23e2c535353a811021cffc43a8ed17a356cf97220992db46a3baf06aa3b059b33528b
+u: 11217e4649d4483737a829785cf3ee7fbcd50c6421c221a6bdf05c464c8c2870b9b00727e3f083355c7a575f576be5d91311f41b131e88de72ec1a6e368e9f9d22110655f94a259470fc8d381d5c5e8f6494fe1ed7f8552f768f2aef64d6bcf0e3778f641a57fd9e35cb2569ded3ed3502d2a46604f69bc9ef0a6be3ec81a1eef09b68a8c2a74004fec213550d8412c2e01469af758e6d66e698fbfa700ddad43a2bdbdcab92d4ea4420bc99cd3fb4b4c6796a9bbb9144b79a1aac3ea0b78842d2ed3ae336c251893cbfdd751b0944b6af87e94c85a52edcfb354f898a4f3136fbd52e42d5231edf964b820f2e56c3861c8787c539f6888e5ee58ad419709f1fb
+c: 973a66a644339954d7793ac176559447f85d4979c37b58a910b1b64b4cdcccb3953d71c5fa5104bc469646b98f9dd491b0466eeb37b1dec4c118684a3cc4531bbab03e57b18def545890ef566fa9c370a7af6f36a655d2d3cb3662d492e87b309ea625e868df03f32da51ada2b205060e7db30138edcb5a25fed2e6380a3fe928992dc01bd9ffb133a0c81beda21b72112caf2b588f4956d976eeb95559a9415bfbd6b487ca8ed460638d247c541d1ec998ba77d80076358c8a7a19a8e5d00102405cd8c59f83f0f489e49a82bd9a045e88fe24d907d77a020ada9f77734ee44f80e77a52592722b3af9f8bed427669310797a1a8ee10379f5bc7e35fe9b265f
+d: 8c99dd452858ae63c23b6040dce9e25817829e88808161fe82c07dee63ba5f4b0a4bd1a7a51b3f968d4d53ba2e89caa9fda8051ab9d616b7af067c679d8a3c2f07e626e0d55e6f5d10423c6a446bf64a692f74abd32ac3b6b13397315659a59647ef88d86ac19750623ef789d488503e8aadf34a1b62554e02797b44fe4fc99ec5d182278f52900c5166323ba1088b81266c8fad9637707f8e920da9df7dc19d7c9a9b215b1c6c6ce091fca9a8c907fe5ff3ed13cc4294e86cf1c56bff376c89bf4a4a77df2ce76f25f2a6ea474e67c4e90ba83ba9ae53420928e05aafd0563ab3e0f6053feb38961aa8ac113b965c86df8f62fc8bd351f56c0ef4c8133dbb11
+e: 0
+h: e0
+k: 20
+l: 
+m: c8203609fdd8ab90aa5bb4c85bceaf6d2ba943d48c444f6480d643ace4d3f6e0ab93ea12cba1fef5f2525c7f4f59097380da810f882e4cb43aed927c596236922d857b1022bafd42a65176a3cc4e74d6cbe8bfc922fd0f132e437a52e6d4b26f53358ae2e6d9b709f7a8bd408a95ad99e77c604ce5e10804fa05f53e
+n: ae5cf7ff5e4f77a5fa99724535a22a2ed52f90ad39140d6d72b0ce514d8dd66538cadab638db04a2893727e8a48700d3c9edecdc0467074f0a86f7305e69862cd90650d33010afd74e9f53fedc5f49cffde0aacd5306f22ad136252dbdc675eaa00cf289addcbc195f242923fcda1b98b78ecaa1cc735064057b2bea2b8d8aa502046be2412646fd78f305f37f4aa2ca093cdc6768094b7b0ef71bb1717f9f0c63e6e334e21abcf337e9b351ae5609a962210e39a819281115cf81795472947da56bf0d26efaf870eb48eadd1485986baad6ba530be5da3f32db14f950ac6f653969f307ea000de3a6381feb7ea76ddcc54b0e58ff093ad7a69bbd598ee9c943
+u: 177dbf578182e5371f0c658d7b261c1673684e47b9f28b0687c3f50d635598e5d8ec92e03a224559656b51bd1fda12bc074914382da099e8797572cd8fbe4d508a486e79a32562c2568f261895dbd5599de04fce4d50ac6dcf9ae0eac04917651f4c4dfbc35fa122c37956cd3c2a3390cbfa89c0a47b2865fcb54e2f7bf96f5406da96c4a0b4fddd060f5880778915e3cd25314d61ec47d1c4a8919be23503afaedaa92891b76423a4a6ca140abc056fa4fc10c095238a950d3b30234662ba7c00bf658aa764302e23efd8c0139524842a88be6d5a1df00b4bef96fb72daba6c5139cbec13e4dd772cb563509e1851d7370cc3aa425319c49df1aef4ecd640c45
+c: 4dd49bd54b3676f0340f511e953a0c33ca219ab7efd2445d2d8001d7e3875d89a6a5b100dfa02ed29e9bdb56f0b69987bbcd045739fad42dc686668f77254bb6787a6e4bd8a8288505f653fbdb536a93f65968b96bff3b59c7e426c71d440c292e522eeba95a47def59fe128de09fa8d7e49dd97d20187ab3ce1eeff0afbd7fa0a0d7ae766605948aeb769be5338f0e6d5b7e35d2c7cb561905a70625f785c8167565a73baffd46becabf119d679e29cb9fb95f594ce14dd68105eecd3ef0a8b1f19ccd941c194373183d11468e96568398ee18a66dc9c4accc6db430f0af57b2ca7b590ea5dd55ae3e672e2e1bd45ae916fd5756858e65ca1139b92452eae13
+d: 209cc03abc2e0fab0c31c37f9326e9fe7f6081f9a74dcb3abdf79571cc37916ecdb5a0fd04a7e402143d1dc297403264148713b2d2dd1af82b8721215c2ca1c418e5148e4d6f02825831bf0295b79dba421f4209ed17f9b77c12779d0e23ebabcb09635ff300ab25ef1e295b1c541b3d72129d60b4769ecac945e0f0938b88b94a4b2db6a2080bf2ada65d835b6dffb87439c0695ff7d700a46f980723529202a7e418f95623e8a3aeec5dd393eeb9502d4236dc8dc8cee369b39e8d4acdc8a3cdb049b538d08bf15160e84595a3862dc77e96e70d04b1bb4437019d5d6825d95a8340457151dfb86ad6fa67ba072b13b7bd8e489684a302d6e05e559bd80349
+e: 0
+h: 100
+k: 20
+l: 
+m: a9225a99cc7c54f57c06da7b29a931647fd23ffe1b8d2c048285db79ca9f247f073c1aa22a8caba8650893d451078134e6c874fe783645562e8d207a94f6489aa1660ba3404391ac6ac8dacb54449429f637e7c110bd9fd23f0a739c32ce8721cc0f6ce42b208d1c9cf9374f31c40e73597d7eb1448726333dd4c331ea65d77f3aa39131068f7cb3681a3c73f57504bc738ad828ed3b42ccb6c7afd11b393ff91fa270240108aef21426f9485f8c4a59ffdad2ad9b831c6b3807cd
+n: dcdd7fc9b9eaac75aa77b98f8862c2290a6c572533cf48f2fd563317fc3a082866565daa7d5d88be0e3612ab4b04f0009b366c3fc529d1f3358d420451f4ad08160a913800fcb111b776d6c4271ae3b782c06f23e032f907376bbda3b86317ef08f247f04bc82f5e94f0f5be2c439b32531f1f549fa950bff496d95caed06a604634fd3e665417571eb93f0e94979aacb34dec059976f9c18d1de56b798a31014e1e34edb3e7530ed4c4c83a2de895eaeffda5871345d9bffb4e89adcc359306aec62a685925bf476547bda3be73eee646aa3e622836de1ea8ba75ca0412acda3ded92f3c1f35877739e76bd73756dc2c2e2b42a0b7769d55bb8433907ad4c13
+u: 128b953a8c0f22662d0b1e164e32265ab277968103620b667f506de09a0a0019c929612f9f9321814503a2b991c42a582846f04dd70345910a53bfa4c3ce3b7c86c192c1e148a1bed636631795f5cd7ae66c2878b41624e091cc3a5e3c4daed81e4eba5732cbf6ccaa19e74897265aec74c0d2dc373e05048474ae8ed9c1a86daa7a6851536ca65bd0859a7bbe08655501359fb38868748f95ad990ee32f8dd2bcdd38a6f37e82612771ec85505babfd80f3e46fe371acf373cf2b163d6366e6f51e971f2c2267ba524b4776a3daf268c94e72c5fadba43004e73ebb12e33b3242143163ea8a64afeb5e89979d6f0b0bba45d3d2b7250a3169a88d93fff37277e
+c: 6488904126b03a5985e2e53d873f193ebe46bf7c172c729f3aebb171e2884c6ce231e43f7436467753ce98625489232ba0bc736f9f93b6ae3ef0ba600a43cc40f0325062476852651653fdc9b460ffd454fe97522e061b603a14397f8586cd57839460a853d73be2b35d96ae516d61c87c3263d19693fa5d030642e9d8930cf3f00d8dcdbaea7118b9400ba6ddff795d65afd523886d8eb5ed48208646dae72dd5ac95270f6e398aa64ad151de6ca808150548823ee17b2c6846d098d1bbf8c88e8ec2245dca799aa9c3d8bf88511205b264f0611f5c942d27050497725c3a1abaa2e709df4f1294799c0011efb6c321a9b4c3ff262edaaf9df3eea327c4c7a7
+d: 4556f01b82b23cebf106641938f06a4acc775f60085ed996cc4a4e572b615f9ef88be014b7829e60832e5e555e93875470cbe6e919c35bf787b05b1775fe4194cff9953738edc5353a8a9871fe7e7ef8c647735dd39a2ea80444c4e02a8123800fbd809f13f1862f24e4d76edafc8f04d071c221cae99a8d7c3f65548bb7903c3cd66ed03d9852774eb3ab5baead66a26d1f2bde48e36ebda2bcbdda66d8fb1b31f368233a2b513d65d2cd2ff58f0b6c2e594e12dc76beec38326473b91c4183a80085949987eae6f52c9a79fc693ba300297d202606d2dfa198c803699477f86ba09448abde81126f74e9d5407a4be5146cdc20afe314c07a822afae77e0601
+e: 0
+h: e0
+k: 20
+l: 
+m: f3906eeb08eba9b4a39bb6a26ad7fb6b64457ddd79999115644ff4811f201075ab6f3a8833edc4fe
+n: ee28abdf087661c8220e35b0065ac4011c3e770cc851eba7e7dd7973d21f7630c1fca77fd718fe4fb0214b0fcdac631edf7f17282a2249f6af30e30127ab33bc2229e6f9c365caf0123e7afbc273a498db7f2b8dbb3a29f82d5bb79042593f1d24d2894fe71b695e5f641ad4336774612e8caa8b5b8f36bd8f12636a56f796562c138ae49da66b600a824b853bdcbc41928e9c22ca6956ef89016d4ef15f551999b551712a6de4ea64923a62e19456756c7a73fa9088510b122830af76612069e28e46c27f6434a7700d758fac06a6469379b0668547de8e81fd9f7ebe7e7e1175f9bd41b067f86e209f66d52d133fc3dd75675e34960bee71b2652fb8797051
+u: 1132d7ac7bd6132fff08a856957936af044dd097417212710dd9aeabf040a28cc8b010b8b106c7cbf3b28c24fcf4d62f7b96cb2be829d1846d38eccbde80435822af085a8b331c3a94a91dc32e1f834bc2ddf61940f2b7353de42448b84c4449fd99e68db3ab172b6fff56524a56da13f5062de3aae6ec83172968260efdd8bed8af1b15399fd519e381ed500c170e75002b4e97fad8851bb634dca1e4d2b18ec5b00879f6c9640b2dd247c3edc6fd6f5cc9e836725e26ed8ae0c41fbcd7a6b5800998c78171eb5386a9eebda6ab3d0f73ee2d7151eef05273e70849f5a3e109c03a08dba876c6f0205e993e4c44510311f8c1efb619372f41a55674345287bcf
+c: 332b33dba645d8d0956bae419d5947f270cdc26ffe8f7d5eac4dd9ec4fc0d2c34dd431b92dc6fa9b9799fa8ea4a1b924df2c32aa2ec44359fa2485c4d787b1bccf047fdf1cb386d2da13f9bbb74a372b5494050772c5b8584ee28592dd926c806f53faa637d44eb0dba86db78a7339462b2f44244276afea654d13d6e0d1527b53eb0a9ee21ba162797fc1a8c62bcb3793e1f85a04a6bff25514a246cca2c0fb9a722d5338fea167cd8d8fb389add6a080d26ac080b4058e63787fe37132c413a69002e94c4ae47f876e380682d529c6ebf6a1f34d823dc31ddc1dce84d5a27ce242564154b047ce399d137b27730e0dcf58040400fa830cec8004fd4a2c809c
+d: a1cd81f6720b1223b4d9b04a283282d142385d7587719fd505517f326fe6f10fea5b0a9516f80e2e2d532909fa997970d690a7d694dd7d2bf7dad0cd3b301554f14d3410526cdc70e8de2962e1ebbeaf35742d36ed867442f7d470ec6a145270e4d1996ebbc93cd440695c562b2b172dd155769ce04abe0a0f2396bf19f8d3ff24cac92bbd07823122330105ea93a5b0f78b2ece158eae9e517a10b7bab209c8c3d6553b1a2e449ada88a96085cc7839789c679331579ac4ac1012d1fade92ab000acf4b28da377b32686d1f294062e4f0af362019e503a3777c945b8e64d82e05351bce2f1ce6adac9988f05c287cf0786819dba424310ce95908ac64c94a59
+e: 0
+h: e0
+k: 20
+l: 
+m: 84693641a0cf915598be5e40678a38580d06fe4bff8eaa3e71c17b0747c32be65f185d25caa0aee69ae51203136a46125cbf86ee0b4dae55874f74a777fe80664ef2ab6d2f7c6e42a8eac53f9577e6304e382f971fc88091f7b53ac2de9d93ca1b14817cda87a75b86704a8a60fa5823142324138d5c9a47a995b90989a62ff06916280640f80055485c92fb268ce55ee159c5
+n: c42932f70302743508d7e4f7d8f661c7dbe72f03dbede32e8e92f5925ff36d3a2919bcecc08e9fd92f29fa8314c97475efcfa6a007d2d9b6e2e868faeecbfed96f929ce3d5ab39f69c543ac3d353a9b61fdbcb5aae8b37bed1a298f73722cf3cece87e4f9a472b9a7e0d436c8c5ee9e3881bd86bc73f0134e7206de14270de951e379ae28f2105d067618a73bcd295b41c63018581f2c5f76aa4ed5d1dd04e3f39b316d14951244d1e2a510c4fa027f8af0820d55092eabae4612aa185e91467e6a172e78b222603cadca753718d9302ee616abb2a11682680349df5598b7e2aa171f8212107946cdabbd90a9762e119f5bc32605bb730282d61b7ad7e7b324d
+u: 14e17d08dd321acba74b5e1563d7455aba07aa2b373038e1df8ea4be243c5dac73ad9497471887e66059b9af0afb9a9e154bedc147c00b11c1fe3ffa25e05a325fb1bdcffc2dc13d37d671afd588b81e28b435fcf97550f1ed4938fb27defeac38cd4bbc07e5f0988259e84483c323645e8dc6db8b5d995eccd58fbf754f3c9529d931fe7ce58b618088943e7fc2639e60d460c95d6774c01a7f1acbf74ea716f789c94641ed938a3236efaa89c5a9251579aaf5f661cd4b6d3d4c7f3b10d14c17e5a1040b16e3bce45ad335d517caba622a1cc986adc2e4ace71747022332e8091100b1aa9c5889140b61d4c8c0a822ff1383dce06dc61a64c5946d096c3b693
+c: 8538d090f3de62c9422289be98b4fd4049a001955a916bb513b31820c6d827c062517a5f466a199aaea8466f4a252e9bafb1e61859ee332e2a84202e0e137dd89422e6ca65d7294862be9cf716825ceec2042ade5df6495c481ea98cbee1e55b783d61ce91d99e8ca098e7611ddcf49e4ffde355433e2c18a1fc0aae47298f2bc075b442440ea371c06716b735f27d3c3cba97349b83956dcf6c62eb2bb5b6c910b288522513c7068190cfb002324723c6cc8683d6929b81367b87f492baa789aff02be399cf469b9f4904a72c284fd84b3511de25740829b28486cae3638dfad9077c6a96706b2f77d624f534f480acf1fe9f20890f66194dd014726627de21
+d: 7643d2c6a7c03ef9a0efd65df34c03c7dcaddf73285c4b4782455f8ebc560d52c627e6cee920795ab4b2a006c3c00e45f57b991c0b74963365e0a70ab27d85f7ed92faa6ad30055a2ab22b86b18857b65152c912febcd13b87e1097f635361308e30ce6c29216fcd18ac19f78edec771d40e8f7c0005e7a69bb5647a74c6a6c93becf2d60ac1edaa332bb149c7fd057d101fbca77453b4b02ca4b7447149bbbe84eb426f5230c3b3dcd26a0dedfe129cc61348f9ce928d411e3cde40878459378a7689ec3360321498991eb59d2963f7c0463e1870ab799cf583ecdce9ff2f2ac6f5f845fa7a46960b5b5fde289ff0d3e99e25d395e3c77f74d8a861ae38d89
+e: 0
+h: 100
+k: 20
+l: 
+m: 322461fcd82bd320e7cfdc00fb48e148e9ab6700595c230dc71e68926fa447c4eaa368c9b95e99de46ae7b1039508c62aa20776ef8b2a6e534746eff7c04b478f5594afef5a3ea57471434cb99c49ea0bc7fc7bc662a49104acb9869548272cca522658b1cc8e4af24f7e73ba1
+n: cc0d6eb58e9aae384a09dcb91c1aaed3933bb6e5180b21ab8c7ce296b9b9534ed9ca62b6fecf467dd48649487d90d5fc24aca257cef07ba1f109cace5a34929597420ce5bdba08439ce003d57e44a531aa398bcaff75a5cc6893a29e2c1f84a9d5f41d86bc964630cc68b9b760fc7be807c44889453e2a23d2e5e7bc732cd4554766635a113feb6c3132e4242d6084f4105b93d381f24143f0d4c07d659f145f6344d8777ab89a48b52e1629bd6b89f76e7eb38fb8af59f5c4742c05c73951c6eff41678aa6ffd91d4584a1f39c60d8440cb24ae62ace0ae7254c11bb1de3573bcc29afa84eb3071ea2fe943c1777658ee90fdb75d8b5077c6eb68843bbefdb5
+u: 1412c1b70c945826793eee333e1990cdb29ae694104b090ccffba573102c17f9efe1bcef1a3bdd4023599626c63511736708e344c35c398b9454289ff3c455c6deec4091f6a029a2dc4bcdeb2451ab8e90383132c127ba432e616e5d1ac2d1434e30352cd6b267c735ed63b0a212e6b98dc8938c15def64cfbd976c091460a2687c1d05f6d0c1a6439343b549a3d1a52129e1c5d779eb9cc845ed5f6e731c611fa17296f04304e11fa297e186e8e9c5963ecdff063e6cccb36d7379f9f65d297c6788946a05f3c6156f529af518bae822611f8265031731425177d220e1056d8a9304ae377cd80d22e3b73466f8d42c2075688dc8c8ddd43d4fc6ef63e9328f39
+c: b539ed21d39e602cf0f6b4261ed897dfc5924a5686522e1a2f913a0d5b525dd0b8bb97d2a8ccc00b57c438c3bbf23e527ae22641fe17e946cfd94ca801b237c4bc4403b7118d11b53dc929b2ee4e0de95e24604c0e567d9628d70052da01402c42459aa75ce1b631a9e83f762fa971c7b5277d225d5de0280bc4d1700da8c365df1f851ceaea648f439c4e008e2c5737178313da40a6c36c716ad53dccee1778b40f505405c528af5db353965468a1858de6a15f23f04e7d656c5c79d91782dffc26ae163e320bcf21774f68fd20c4f2879405c67ac1ed45385e214039c30efdd1ae0fccba6ba88107fb20af94302fe33f63d7c25a9612b7631998646174af23
+d: afb8fc5809fcd8297bfc75c057df25bc379af8388459fe518a186149b5b6f48c109285833033cfd3a13219ff59b50333f4b2e9e406406e4aa24b8d644957eb6414cca56c2c47a9e14575e1d3da36d74df8f45d36a665e491b98aaca647b9c46345ad96a385f368c66e65de7a351241b72160dd489de9ecc232f9894736d37d067b3eec61721c2d71af83d1e903ee5649e0fa038a960d5cae5dd621b04f0f0210ed0176481f3ef19d46750507133e2dac56f4776e260833eb105aab54897cef30da57d04b555194e34cbc2d43e8b4a24c72efcf04c42f72028532cb1e50c3fe53ae933094e9bbbab5ebdfcf333b8f8dcc5c605849127582f201618ad85505a1c1
+e: 0
+h: e0
+k: 20
+l: 
+m: da98ec07503a512c53e93417c22d22ca17827996d54940a0772f5e3403ca7b9a48142ea06847418e25ba1c106316bad610a48d1636b2c2b6adcea43e4a3ee58080471b0f16e3606e5fcc27daf8495db90c907432392239e249f9e8cb67f86ce6db9f3d4015cb26a4d4b9a06dfaf0b92e1421639465400bf5f12dc34f025e58b438a5dacee4b2c4e6ee8e63c813769eb1ab2dd69276ca781a7eed5ba3848c9de2fc823cae2c356c8aac8fec52bcc71a43002a72d5d9fe1870f9
+n: ca6648fd9a799ae53c23fbc1a1612891019a4119e2effd884734382d6b605c4d1a74146a8345ee633adeee86f29b860108ccc2e1f1050bc9c73d2a4bd78214663d9d85c2aa624c9b8b1b622869792f0d42a3a0af3bace2d913f25e47d1637490c1eff9ab8d7b46e00c2631725172552d1518c3178cb95338e672a656bc6dfeed50599f9f9397c6e7b20c1c72a9a5115474dcca2f67585177a0930d656b103b04a240bdf123f7f908c9b9b85fee92b15c10d87bee0922e34b09a2b7229d9e7c36b8d2a124b312dcae476b0f8ed6877fa85456564180080373a12701ebe2ad5b3dcbcbec9ce63edb3f159d8db73b1a57736a131d335f9d88f7d57ef85a826d23d1
+u: 143cb9132dbab9abe8e47004f3c3df733c4cc49c254bc6b0a8c54d824ae245afaf0f9d539f4ad0856aa46c5d950bb4760cce44ddec6a20492de4643c5e07e69d228ded6a335061ee2195c7d0ba1bd6ee95cf7e5ccaed1547daeb608419a90de76c6b570971a3608cf6c2048dab82e8797273f1d8eeefe83c1b06d6cea49929548731a61efbbc336d2b6264f6e4d173bd69a288e14882b0acb7d68eee2892e1dc2d110de56ffe70ccdc78ca9131c7391f5bbbff4fa35ca1f22bccd0534c295aff8eb9d8eca80ce904d45784f2ba55ccc8afa9921b1ae2c16cffd11e1d8429e56c07f0d03e64f924766d66ebb141983671f8800dee91340d25fb7b74ba5dd31e27e
+c: 899b66eadf3ceaf99763d2f0e7ca9a5bd998c5a1408ef1978eac5b8df4ca9433cbac68873d90b32482c2d2bd6085a558ee65bc4a2a5b2d903ce7f7d1f0f47a1f9f0c2e1ef16be31b63d0d3ec2daf18b76e9ca3d47a89a6e38d75aed41677ff5a99c2e76d41ef5ae97aedabe310533e55dc79d326ce7dec1461cc446a530590b009e8c0aa084f89b307924b6a9c30228cf4cb9384a7719357dc2738bd514d0b22dc6279b1d548a38a419b6c5ead9d0f93d375d95d52541f52c11297441f86b5f4032beafbc0079ab107fe56e5212c893103f26addc1ce87f407b92e6e3b0985c29cf4adad27a793ed45233e1dd0618567acff9d1da4e8cee752b875eff72d60f9
+d: b1b12055daacf19b5625e6e7a98dc3314b7c582662005bc5855dbeecc9aafda3bf18dd7b48015e1b57154bf3e2c86a0f6e47d7ca68cfbe160eb2bb3aadca079a3e9a76234763ced7118dd15f856986ee858675c58f159b56ffa2b9f4ea1bd31af0ea029042a86c7bd463c1e49da75fcfad8c6e6747ef47d0a58a3a3fe5de3e863aac0081b6c39ce01133e1eda77ad87e42c1a7c15eb882e21b499c5ca5c0e00fb6c31a98c25748f80eaf9196b9652ea2e6474221b2dd4336ad219780f58aff85f470a982ad8b72a95b4624004578bea61eeff889266c763106a2fbf17469c7d5afcd3d18790454315cb5c25178300c9dbb4eca1bb7d6be414a6aacf4e05c5f01
+e: 1
+h: e0
+k: 20
+l: 27794d60655747264f5a682323736c2f78793e7c4571692a5d3d613c76536b5b38543c635530296f272a38574e5f663a4834707238453b24442b7c62696d7a25447b6c7a4e3f453d654d75226d7d373472576e7861394d486d60687d2e2b214926255d29226978352d30783a5c5c5a735e4d585b33402b386b4f6f503f6e5e
+m: fe6600bf2a7928fc36d1b0bd7679f806699c5bab5f1a94b09fdb72e6aeafcf0e4bfca419
+n: c7a04eab94b9b314f53146f9c0c2d452a2d0d50a81a4fe3342dba5e43ba550cf89beaf9f8cd59e1b79f6e2b0dd0468dd23e946ff05079d061831317d4d1d956f1b0d9274d33c0f6cb161c029f28f027e28acfc8ac398450161d9c6873ff7d7cc0f301c9f44a31a6b4a6cc9f8d6108f3278e42d71d837adb57dcd0615348309db42a1917ac298fff8dbe1ef8ddc30beee2503f497eb1d44bb1780033f16edc99b7f2e693dbc45ff30dec59f749b675800fb989a5b605b7716a4d8e9266fecdf38035cac66300131d301968e3cf7712c8c1a9dda1ba3a0c747ceaa49012b17a600e2371fa268503efbfff942033cca7d3f7915b827f9dc46f7c476bf89a0010d97
+u: 1484b280f792d48720df24400d1cae3f7072fdaa1636f6d0030a8d9df29772d79257d216b249e39ffb5a4921ea26a168aeed1ca56c5b950f71f138c53a6938afcd8a3382ea3bd3441cd2d1d65ddf5654471ad5b1e74246de4f3ee2e56c15b878ed793c2c84adc115e04655f09a18001eeef2268916a6ae038255d961e4ce668d487821d6e70921ff3cc71b0436e6f3357a26431a7b3bb631458f60415962c4d239e90004a27f5c5b9b7103f4acbecc161255e5206604d9079ef5f37478d3217a1b3e39bd2f1b8833022211eec1f1ec0c923f5aaf5f5f35c0ff7811c40162f8739e37f2d40bad100deeb96a5ac928a8b97b1adeace19445e2d851a4fceda258fa4
+c: 87ab2b8b5a7bf99e8dbc9b70984e384bd68c19639404cae72bc7a2c1fd1fb7afd135be6de56b037652e3ade66fbf38b26583695380e29ac6efec55df3b7ae81d6ace11ebefc1a690a8fefecc40b139ec500c2e7b62f9698f557ab510225e577750371113a074bccd621b3c229abacf03507d05a2db3f4fa2129b361bc53f4ac1d6694211c2720f573660e5c0900dcead5db853b226f2cefbb5e4945cf4b3b1991cf379b4f0fadb246d6b8762125d0b1992adcd85890952846e1a93496e4d674c5bf74bf8b510158f5e0ad25ffe58dfc768e8e601dcdabab182383fafbeed6512ea05fc3de5219ddb39d3e3a578a298e5b44c520d3050860b3f43598b3f1de007
+d: 67081623bd34c41d3f1ec0465ff4838749e04e541cc7bebc2e675f23c62c6739379501c7ac7fca63a21ca50ea1820c1d95f3009f4846338b353841654712c4417f9cc5c8aee4b86f769bcac29f876078fce892a76d68db801392f128c91254c3a10e6dbabe0ecb30995b48e9b29835c5966a5579e160ac94b6bc677526caa12ec1435349ad48bbac8155cd3ad967741196fc3e85861b57dccfacfb70f70ea1201de8d492d8a71b57e4b816c09b02c382ae88bf7d45574c0076984b21ad4776eb37ec15dc82afa284d44d5f0795a0848046a72e0314d1a81d3cbb3ae89f4eb8ce9a6fc14d8dfc30d43b8d7358cddc2e3510883305cb9a6ee7034b5b41db1fbe41
+e: 0
+h: 200
+k: 20
+l: 
+m: 9092d3613a5b966be1912e56be546287b92229ba5545139e0917b4dcaaf314f84b5b57ef24d570a9139bee98e52091403b187d0f9effff6611c9b9faaddbd0c8dc83
+n: ab0cdfad8878fde9740e00ea4a34e34f2d6b00c7e98fa6cae1f573d776ef68572667c4a0d0cfdfdb59acfcba1539214745222749a620d00be2a8998c352d495c0899ce62f6fb67804423992a10330cafdadd438575f33e56e4720fe63af4992ff2d5feddc210d12cb9498dd862ffaa47d41bfd04b00b4be8acf9525e7620e43bdcf044878f2a56620205599dc752ef2f39e6a3b0e3b79c81db380ed06ddb70a6123413ef2701dc6f99c42f08162012af52274eaecba5e79dc438d1c3522c08fc9ef08deee1c7d05c11aedf2d9d34a7599489df82d9182e727163859d429f6f5b8b0d1abb58814f684f8e6a12c8e560f711ec3d5f7336511f7f1dc0ad96900549
+u: 17f2387972c39deeadb0aba33da576b124673c1d48eb8abbc6a52f5c75456a9d269bf4626b1f560dd7ead7edcf3aae2714d1d741cc47910882b2156abe7c4f2b63c15125a4b69da552a66ceb1117e7aefe536e27c488192ecdd868d5c9dbd7e99b5c0d97473b534d3f9f9d8152ca394838f9dafbf45222fd8afdfab7992ec1ed4ef8587fa2e972ec7b23a12c2db7edd76ca1910f564d4f878b0092e73417951b45acd2f34893dd44a25d3e79efdfe8398d51b6063c0acb635031fcb6245502f5d01dbc03249171e1d93037b527210c0d4e5c5b69b6965a34761e40d7a69424ca75ea0888679089c3c05d2c30db6bfa19d20cb9b9c72edbbcb622074bd467d40d3
+c: 6a43e69201948d0b31daccd513dd901d70d145b80cff63de218740fe00774a5242fb45dc95ec66e23021f605388f89a343116f878a15f7f6b2e32535d913447b05035d1ff68d55ecd4cd1ef9d54c510a01666173a82272ac006d88a0159ae7c9ee9f41c8d84290245738ad677e137bd6a9ac15320612f6b0e9f36787eebd437b398f698dbb90a59d51835f61ad37692699cf63bc72a8d177a83c35c4b02c3935e3afe470b049f5c3f74a1b215972ab0aac1d348344ad464f1043d89b21407e5149db2c700342f010281c17e7e6ae920c6537749304942f0efdae712a944fde83dbd3522b009eaf4d933587a562da50a0160a2d931b2b0df9fd5f3a8829b72618
+d: 3536ab6fe04b20788b0a83374528187075994e3fb0ed92675a828071f3636bd9c64f108d92353c30c164998278fb86356421cfdf93aa89d39b507ff55db4d8dcd2f26ddf61d2aa069f9f1c4edac61659d4fe911a475157b3b710ae7ee13ef42197fdef98719ca6a501d546b34d50388aa80214c6569aadb34de256c808292fbc018bb1d2245639abcff6b48f77affd8edab0b2472588655f3df098f4eb10bbe212bf0542f266ed3d899c6a18f15e2ebed9d496ecbad09b6c6609854862f6f036a7c84a5b1ec022a64a5588473f98b3c74d7e7b2f27d8ddc83371c78f6d171517e3425466ff22f324748523cccc45790e1dc625c4b31957a87361e02e58c17fc1
+e: 1
+h: 200
+k: 20
+l: 29216d3c3d347448253a3334262a766b766a362565694f7c7a31
+m: f7082988affb94acf1c23d32cb195e8bcd92b3f92b65148de42ccca35219f6c28d9cd06c279c580399de6cd2608188171385684f4a02b21e9cdd92203a49ca
+n: bcaca213fed2a37a89525ac4c8895b5c6f27c649ab6c3dac15302ed192b75c6c2b55771e025d9a4255b8af9a524baa0873feb9d40fdf9cb2e6683229846126868feabcefc38847b458f099186b198dfcb8eda2f0e1bf2b563d551d69331a7ffad97db1f9b3823f49f6f2368558a1d8d131faf831cb9b3ba316f54302b32d979879e4b1da46778e18dc476544754e940e3556238c36f2cb7cbc0798ed17f69ea6565b4c172af1e5e6345b84948a64e97bb7bc61099295b68ef747733fb5cf14c0961c72d753b7626b70b74a77a75b5986fd66b14d094fef0ac61fb7baa2fc553e15a50c4a2701ce0dd019a0cdcee93c0715fcf419e0bdbf5c4008bf3b963bab23
+u: 15b598d8188343c7db398bb3f6a4af0ae82583f235a0ab78b39096e28dad08272b003e6ef62300a8ad38a4359a3ae2ef56be5af8a1b80ad20db732ec774de2e99c978142e4cc627218bd6a842c0a70c7fc940b10ff51e40a5e629c129ed0cc9cc30db0f10e791841941f8e4e250b976e9ebceceb3c79a64767ab8f73df140ffa282e1f7cbf9f6111fcf3ac6a47eb7e0a03217134c90a4b78055a30b8f4f791721b89d1954463482d9dc9aef0211c5286faf9b6c652cf656bcebdeead8ea5de0caa63d95a220b19d21b19ba1ba9b32f759d178922d4cee02eb3b06533a534c3286b2175b603d33ce5616b581d3bf64f110785755b7528b3e0576bf24ca41810a32
+c: 991751245acb2b1a75e6106887ea8df2bebe51f332b97c6d82cf1e855b2f2be6f45d2e9f6ce460c0f4489a9961ebe8dfaefcc96836e348fb9af8cb31dc120aa983c86ee74fd7e75a937b44624286a4fa645ffe48642f12ca4b5b2474ee6c35c1d7ad87a434b21ec7716f05602313c580aa8a6738ba9d91b678de305ffeea2b21e10874c80b40371873ca6449cb275adfbd8cc37041db937427860f831a47492bdc25d7b1941499b4ef1a627cea4c80a9daa34a5ef3f3f0bded1f179a16a44ea53fe42cf36495a01b8d6771789de9b94bbac853396b1d0af5f8b62bb17078ce124f0e20ba6b1cd96befdbe5469b88e2deb7cb51587763f8f3567d798c4632cf85
+d: 5fb43cc248daa92a3996d0e45ebe74ede7d26f0df0ee0de65bf03184d03477ea22f5b7e838caf52871bc705283f8fba37e1db99c9f42f172861f830a8b97cdc9a258f422906b356611c299635600734af8ffb0104441be7d973756f8478472adccca0441e1b1ca89fe1282d96de8ee6cbd6f7a4d1a9283abb8ce2f859efd73e10a19787ea26ed568f6956b243aab6cdeeb53cf27183285a9daa9c0b1ab134228580337cf71e1601e9f57e6566f82fb31c086210b52a4e82279cb12e891c82385bbe606bd7f10803136259feaccb42c2169fa7642912a06346defa594b3f53ba71a2b218313486f495bbca8845f41a667125dc4803c9114eac5ca9d9f01165a41
+e: 1
+h: 100
+k: 20
+l: 592635264d6c4757715b544c6824295f30575c74797751385a697b44392d752050665f7b605a66716a783c503b5d46434a592e27425b47627d3f7e2c662c354c2e34676b65302544555b3e624c5b653c2f32215a463433652f766c283a762c544b6f5b6156745b39747b5f4d582d683d3e6d4f
+m: 28e33d63592c2270b8f824b24a32084b791f9c37f60d8a0c1ce7cf0887a7b41a73bf50ccaf04e5c94a2c37da646b25875c81776da8e85cc4bf1ee098b733465b51411ca0ccf4dc3ea6fe909e7bbb7bb8d21fdadeda89497c4e949e3962cf31d1505d35382b484ab3d6041e004983cb15a5918bd9c2422e169d3a9350605e5ac5c891f599
+n: c192b8747841c00ae4a7e50945c932a58ad9b4402768acf76717e337b6c12076073c6670cbed76e6c9b27e7f9d7d518e25f6fdb21b0461f301fdc3f06098e7fa2fa569f1f8ff86467fe70efab3a133862c3bcd1e6b9fc24e4331ff5554f86ab59e4021777d926716551447d5475cc5f155c9bc4f9d654a1c621c59b827975a858ce3b06733814bb92e278ccc3c6286244ccaddc670961ffd9a4dc92c73270ab2b0a18594b89485c1a6f06dcac5c051e9afcdaaaa62af9ced9bab4ae1e1b4a6a04c4422c796aa140329c4ebef80b734bd1c87cc1acaa27f6bc4c4fcfe3971682c26725c113d976611f7652e275ff03c2930c13b17a0e6e355b3d888d2b59665bf
+u: 1528f343eaad149ce6e664c6eb2cfe3407305b8e62277eca44afba7e5b852770dc3552b3e6be685f331df1ae22e52c25a3c059c4f0e3bcbdd24bfd03d4e5a4840bd089a82287bbad5045491c618e515ab8f2169cc735d8c8a0ab92f3a113debcb4392d780891e5f2d7747817514af17c243641e61167408db9a4c95359facd1e8ff62b1eb7bd1aa756e6f34189c9f5a900c53444d82aee4b74aab303b8f3fa237b06474d17483bc1d20f57b508dee504d4ead36da34db30932738fb48787af69dbcb6990a585894ea90c57394434ade94d409d88f3797094b2ef64c176720b1f9b2e9797a78c11690ed08a7201629107b1fb03641ac196ee9fceb2fb186302da1
+c: 2a32fefe42c34c7477184b2809639f932a932a236a2b7b210e0bc32a8058a0d76d6f749699f296916716736f8f988a93fd957d80a8b01f8caaea23b3c9a17c06c06d772887b50414a51a0fc626bc975dc7ab42985a9b16e2758fc29af93ac7278e0b0bfe4dec810c8c43190cfc143ded07970d78f52d720e261b2230c05a61438ffba0f161eab1a3ca1ae7974587402c4097f5f60f08c362020315770c138baa2c399deb6cf1f3c2923ab8076599bca597fd690e6473e734df397ea49e98e624fedd6ea78bc54f73a8a2d1366ec296387b343ea48875f1d8ca22c21b081fcf77e2b0cb42560dffb097dbcdb305c2210928590eb6da742586f02531a3134fc418
+d: ed221fd1b01ee99e448b3f1707df7543f5cdf12a68f5d4457d0f993397bbe2202308b4ba8e77ed31a1a28dbfbac32055f12d73f1ecd0fa91b84e7bbc6205cd8c1a939ecd322fc97b86b510d4ed5d8302da35da9c203ae5a4d6f8675a7eecf83a0c44ba4eb8b495e81e51356532ef34b0cf39c7b396ec207c7174a44b669dd672be0e5007a2e4f0aec87bd51b458fc814991933d2c1d170d601b21483c99867334d82a3db55e2d46fb7eaec4c0d6575dc48d4785038f557be53cf266f9b8aea5805dd06c9e8836ebdee39d13556b1fa8ff2a3cb3eda554ae0e030b8e1a9f005c173e9209fa771ca9061b07324e3816e0601c07d04d04c4ef1fcefc0704fb80e1
+e: 1
+h: 100
+k: 20
+l: 5b413271702b7e4d7d
+m: e77c7dd9e2567acebceea24f0fc9be9800bfd6edd27230f54a20d64ff986880ccfb9b064a6b2b7d9bc627b44b5b928f8a788f2061b98eda5f596c8d891ee55c4c679169fc86ae620365f0faab184bea8a486f727047ac4b5e03b399464754ab792a8b7f9038b2dc0240b5830f61b638ea98c57dbb93848988764f1e522eb173d75dd
+n: 9e4c2203365d3038dc652422e59b8744b39d23b1773d3d3bf4dfaebc5f6a1f47c607e7cf71f24de054a9ad7b59750e6ad9f59546ad66670ed185fa0540418ae4e70cd53246c03d3145e25b250b25575d5d44e4d844a63b53999c083a02305f8f32bac2a32dbc1dc7bab9cb12a118a2a0e2e8074b58328b1ec0e1042c15f8261952ddb3b904d1b6bb97235af7984bd46796d415acb7283b0b1e3223777635e9a6c2383dbab0d54c60fdddae594bde922adcd5976000f02f5b612b58e62ec2330fae8bc1fcb3a9920c15326582013d31e345971361a1fac2d7bf3d2ed79ab49d7958050718dbcfc7b8ceed21974785c04e01788c39083822b739443749a5346f39
+u: 19e016bdd5112425f515b1a10ed72d4cb05ba49671e39b10f2656a5af284220bfa7c09555287492dbfdfc85329ac7f3ef941fc9cb4109612d21d72b211eaac33407881b1a9e808d7a9bd262e2343d05de723d5921fa309caae6c893709db47724e863fb5ca24b7b0365f4cfd481779f54d8afafbc78e76f309ef78c7a0ac430ca31adfd0bcfb01bc16aeb23b0505174627f920f335e37a8f80f7a94cf38d7797f7e0ed231e579f91d043e18fe6803602646f7028c63aef7a86066f95ffaae7974473f7a4dfc3395e91e1f8583555b28aaf676d8f2a56a5c2162fefb5eb69fa659ac2881912eb55055ef910111c9eb1a3b6489a0d2a921ab81897a453b23dd010f
+c: 0e5371e94713457314aa40e586ca12ea6af4ff5ecc66b040f591961a0697b267355113b600158a1a4df2d42dc58c862e6b8a38f633dcedc3fb25f0a918481588175d05abb8caea8d716517c75f8df7aa0d9b3ece845343c9fdf7323df6af7f30853f6c6bfc8695b7eaa525b158861428e526fe816e6d13a5df2ce8c55730055103673b98e0c0c6b7fd5623defb6e69498e694683034fd04b13ae1121941d3627c7cb2b150d5c7109a04c74d5c19d5282e1f07ece18236cd6d902da9b6b5e982c26ae3b1c676586c6787a0111ecf8046e2af90e6c946dfac2e46a94cc822ac529f3a60c05317944ebb474efdda9665bc1310b6e7d36836fc7874dd1deaa295566
+d: 145171b69cfcb6507e5d9d04f358ec0f20425f8b7dc3eb169019d305dcb8c4ff308832f40f499b80f0c2dbeaf844baa3cdfa302ccab68215fb57ed86606c35e8dff5dc5e9dceee51f7934b570b28aa8adc79be20fc6fa5a33efbee86211b69e927757b3e4c20784b1ee9bac993d59967392b2ec3b81223bcfe603912eaa16444b18db5534f3989303992c4f68ecb6acec7ea90644ef2ea422c91e12a88a19c6a8ebbc95fecbb8c2da6b9a1279803cdf78367d5f200e8e97f77bc8fe9dedc49bbd937a562605eae93fed1e837fd8deef2ecdcf8a87d072801d355ca3eb895fcd9e13c2a266b517beae245c3b48b27a356491036d890a45e3dfdb429ee19778aa1
+e: 1
+h: 200
+k: 20
+l: 4f635348656e242f647b4d5751566b765f405044773a736233787e33357d564d3b323f3d4848296f7443675943256f4e2a2a362a6961323e4e5c4d6b762b737064302a3e266023357479253f477e43395a742c376346674b682a663a2a256e44326e64237a7b537b6a2d53392c2f6f2e575651
+m: 6e002fae0db8a245d08e259c3180488e4cc64aa6e735c9d6
+n: af6abcecb31eb2fb2208016f787df93078eafbb66401833ca473b6337455fcb19351f74ed24ae4f01ff6b70c8497db537cf29ddcafe1acda4f9600252988c33b624364586e4340128b754a2bb92b64954c22c199e6ff7f22eceb0a6c3df835d7c79134c5551ca55e91c8d133848ab7265d17a36c84cd094ff6bbb0a6db6b71161f58d241b49682c915b7949912a3f4a12b559bb8d21faf492cf8a31998c42716e0caf488f3c3c3f511539a0f30a235e99824239bd724da3ef2800c3ee41be3e69019ef07e6070791f4da97a64ac679d3ebc034c6a20dfdfb6a0239cc423f11d5afbc12de8fcca9d62c0eae9ff55a3214d297c51a7798d23c547d791946e020f5
+u: 17599ef3f91ccbb48ab965e37c23ce79224965f7fab18d56b67b0d7be285cfbd71b75b514974d90b2c8fccc3b48b360e525ea439aa0ece1645028c04b46095fc557b033cce5a89d6ceb5fed6beb5c1a1babcbd320625886cc26153c6d1c12d41bbccb844603722ef63defbb6b981a680928561a9b3d09cd94b2903ee4924ad395d06b3ef0b99ac02b3534a18e0922b1a71888a39d9c3256402eab50cbb4daeedf6068c488e15d78df7599070c9423e033803347b9ba924b2ca9310412ce7f19e20ea0c8e60ab0fe14fed1e05d7b56ab369cf33852d1cb356f23e0691e2c05c4297e3e9ffe1e56ad4205e7ab65817af0b6a13aad2382507ffd809c003c79564899
+c: 4408a4b1448b4572766853550c814f3faffd8c64a801022c84e9385b3e1cef9fc33ce50840d7e5d0b83c117ce2cc673cfe3fd816bc24ae2b25e07296aa68569f96286a4d81f360c435d37054ffbd8c16171b5eeb19a7ed4c8558abe0e2acf08af7ea0f64a4dd2e4ebcbc7edcc45a6b2ac28a68ffe34d6d6c22feab461eff615a83fedb8e1bf6b1058cac2224e6b0e27626b92cebd1894c211b311e72bb60ad249413a288a46d01689b85b2494fb9d5c66d0e206588bee7cfe294a01195eb97d46a97552e7b39de8ae3519c782496b9ae950ffd358ff05346900d20b35969ce49d2227fc476f2113943f41ae8c0a8813f34dca495c741b282906b06f56ac70560
+d: 1ff41eb5a662da4193b4d027c35dc423ab4bad05b6b3b91185d9fd91b3114e6712c5f79b3bd6e10c4e8149dbe8799836f76192c398c98d946ceae36b332bf58d2584a56945bbe7adf3ba577e45fa55a8933bbb1ae7b5d9dd51286295632b4b74536aea7b4f03d2f7fad07d2e7c2a717a6a267bca15b9883c62326b0e0d57aec9f1ed116f35d4f14312acd3072764dd5c715444bc14807ae3c198b879eabe337bc0a0455ca8d1c2e8b26512e0a4698c0f07d23f1808494c4f765f0608e1040f1ccf047118dba8833fa08e49c5294610876627ae5c68859328407fc229c98dcb52831ffbeacb652c992ff59074b4ed56c986ae0e50a9ca7e0c2817f6d8edbab001
+e: 1
+h: 100
+k: 20
+l: 60746e6937767a422c517d5b2576546234562f735a387b6d712a76543a683d474b5d645c2f764659534175675724376151785a6f693d6923234f36775221724a51745d7021673e393b456d666a4e7a77595d632d29655624426169265b5f4c493259722e71726d2e6d334236323041296e7428724f4f4b29
+m: a3ac7aba2307c8fb7c660f9a702f5079e03e6c332d4d6501b963ff6cae6f5350fa1ccf56ac72c5a7d11432967e56af86cfd673fc53bcfa18a4c98621515811bc84cdcff3e2a48215b2d6b4bc10f2445ef8ad48e4c784f766fb08620ece425fe3861fec9daa30406d9be75be40d7d1bd45323f899704bed9ed83536a1c68ccb709ef1652db2681aa5112e25ceb6bc9ef69b020668c8f5756e982fbf2a2be7eaef7ec5263af1d8205569533d78f45e476d0a5b2ddd9766830302b9e0ad
+n: c4d1632b9f9439d9d6f67806a10c1d4aab4ae201a1242e525b20cdd9e76f4a1d491257cce20615a271818c719ebca5eeaabe6a5fbfa4883a61c391a98ac23b1e4b1c5d7eebb8b83fcb1322157f3ea4d57bad316f52667019ac3723bf76f84483a147effb3956aa0d6b9bb79a35b97ec4fedde19a0579fbe86222f7283cf6486b40a455d68243f99d34eaf7b8305c5fc796a7e8891d9d183cceaccb86a526085d139542adc6bab95293ec212f77d164d1bc594d306851a415cde839cc8098c3c2ba30add15e15c2d20abdf448168eb1260ae0f2c48a506ae68a3d8b7f5bc595a57504117f5ad5e87a478ad9a6b9fd5528e9afff7ca0db0d52e312d88506d0fd19
+u: 14cfa51d323c031a7fae7fc9eecab518fdef872906b25ec1055c5c13d87f916ddff980c8f3bf27086c5bcaefa644278eb5d081ca750840126c4022d10af43b14f020127d565b097597290aa6858e35d4a828afdd73fa7dc5b93818077b051ff7f3fdc00eb3887f6c5b284c47668d9b0e4191fabab0108645f3966750259359abc322859d8006acad26628724f42def31f477da07c3b4fde86628ed08e2e336b4740e395c22050cb60c594d702f53d60f9eb34f3c62dfdd33a74a38faffa00440945f8d7096d6b2c135f2698b660c7067d3cca50ef3e5d7af0280812e5b6268be40ed7f33d86446b81e5a9b30941417e2761f5474058c9317068c73a965bbad800
+c: 821a9faf32b760485c875716c28b190ad290218fb7120d061ff5bf1f1b5588488e04378d75d1337f1978c6564b23ad272c2da9df22f19a9ef0b9d71d3e536c879bdcf362ddd93aecf61bd3d493c1358eab10731f0815bbe49657e9cce408fad0174dfcea41c4a6acb680ce689b41d1a68af3a09b486e0e67d7fd016c4fdba279a8437ee8c92ece576ab775258a0451d00012c71ec30e84674a5be2206b0f45cf808c5432e1115a010a7ffac5728bd8658e04400db9377e351984958a468151b41ed97a40e259f340dccff36e0008b0bb6e7ba0f5a5e48b0bf514def0a13bb6fa178e84c1306408f0e941480052cfdd75aaadbf1cfda72c259c812cfb11970efc
+d: 51a28699fbe2b4608d148cdfdf1e4fc349d2e48ae63744e99b970de94a4830266dd9a4f6f730cbf5340017f718f13b1f8d4f28d0f5f2d14cfaced22e8ef797193d1a58fc43d9e68072b66d00c4463783b9460ac50befa797cef82f8f60b182216f9abc928d8f371b46aedcb8154898fcb6fc80fd59cab7b8fddc6622a28955e4097ac6869fab65c24303bdcbb5e2740072b9e8e772c6e3fe68a6db3eb8593cc4df049dedacd9d8429309fde50df4878dda0e09e15961cafd05cd335327b0eff80aacb2a6e4340541f44dfbfff43a21c51cd98a88d80915de9f3c4bd4e64f1831227b7e3376b678fafa32957db12cd2c104658d9b829c1e3b6ace52be9d3c9329
+e: 1
+h: 200
+k: 20
+l: 782324472e60
+m: f30755289c4719d19f465aa6ca4a2a985f4955cf17b7bc3cfee8289eb3f7f68a078987d25749ddef37d852ced2198cb74e1c7cf42c13b71a81950cee4d3ff07a2dfbe1fa0d72e083751783bcc5fba18183f803046cf4f061c70a415209c44562b67869
+n: acb374a553acdea664830300d16b53d4e0758761c1d35a3cf934589f5333d76e36645c53a12a0bf73d7bee0b6d899d8527ed7951dfda3ed1957ad080ec317781f6db626ac1c489a03bf3ab13703ca74e3d154344568af9714650c1c343a0fdc0777e75d57e28cfbc6b03fc854285148bc9b387226cb3666cfa4d220bebf7f8a5862a77f5837d7a08014594e597165f6ba17d9b0cb3a97c1b43879ef8133234fe36b77e81502f9d5d504e7d9c8a54b0bbc65f025b4ead54122f018f36b195f6ff51e95a5a411d1a4594ed25268eb5ccfd281433b467acba1027c5befa9449fed0af861f5dd79b0f8d11cb48b062810a4ee383440f1b4e868d320022d9cbc57d03
+u: 17b7a0718d17b5ffb0fbdf546d78fbaac411d768d41df9191c2cebf398ae53d5e7816ed37bb8773164a73fbe14b1c8917c670c7f15695d5eef9c0a9f358cdd3bf83d3fee793a3f061427fe0d49d59049ca829cc1196362a1fac671bc7526c5d9ebf441c5aa9d3f1eb949c43c2ef968128e95446569117e02e76c3d58497f5624ce4faa6acbb6fe6e952d427bd804a001f225b617f5fa15c15bec905a08425e73fecd0ddfe361378bc281ea1f4bd8e8cfd019226d1a3021d80f6e992bace87cb19b12f072163455829a63973b595064874b34c55bbd82a1b23ddc681f5ae29e1fa4e02a6df9f49eea005c30bdd1f3609295d5d1ab6e95ca582b0f398c234735233
+c: 03a87273186224450a26e6e75043600248bf7d335cb051611e67785c29162aca6ac963d8339939abdb7fed6ea9f350da09d810c3d8f4165881d58dd97d2e2299762848e54e125317fab3af0acfd3550abcbdf625b1ef5924931a48ffdbf8852fae74945f2cc87ce0d298ebf1dc489034579e321317e7c752b7c67391df80925586040cb1e260d66ea4f78de1ebe1ddd505c1630d21b2a6de1f667f6d890fd141c28a0760c9e2f3a65be276137784946f1c08ca511b1844eecf596f563a9e0101b1a3f7ad0453fa7df8f9c33bd9ee8b08a15f414092688ce83eb7a52406fc184ee4bac1a2dfacd544a0ab948f770e9f972d5c706df965e0414734227f53f8a4ad
+d: 27d3cbe5d890a7162ffb3defd9d25df434ad0d4f42356f52d2feef79f6eba0b864319f0e3a50d9525872e7f1f284b526a4e2e38e1412986a1ab9e5ad35149acfb6384aa549b0bff8123a23fb06b5c47e25419ac0a5b4cb76f6400f2cfd5379378b95adea6db9a27639960b5fd04ab461582715198185fb17e988cd36ee53aa351a70222e90270b240d569c5fb1f05d24493532edf9d819bb13ca115ba904d472251518cf6104f727a83dcf18fbe2a6305527dea0954ac6da4eef661e9b8f2c1c1c19effda64fe828ca56b14cc9195c9052ed63d70c5d39d43cb0e268a52fb68cd571d800f85eefcf9be5bbae87a079dcdb2607495d9fb288d4adeaff5faa32c1
+e: 0
+h: 180
+k: 20
+l: 
+m: 976ea016f59f145fdbe1441f3ae0ea9fd995dfc0d52382909c717bedaa39dc66714e2db9758cc0cc32d259ed6c70c042336a0d54607f0b81d75d30503ae2bfa5b25e1ca3e8fd646819301a61c85c86c1c35b1d2e50faa4fec1947436cea7cfc054e405
+n: b844be5f1b63a0eaa3a7fc01f28ece79193bf26a39038d47727c7e4ef2e3d171edc86e5028c15f1a25a66710e8078324584b7ac911fe9960b10a53a9157c2cf87b790c71cab8e9f2b3b809c7c52b6a1133604f457f74eefd3acf1a59d499036f24c392ea40854ec6c3bb7c51d3c471c964d5dbe6bedfee9cb3a7dad6714a60ffaac3c7e9d81b4763020382ca6d445675166e3073b66ab0575660d958795eba46569ebfd0d22b7ddded36cc274fcabb03552ac8342d1f6358ed87e7ae5b698b08f2ba1861182c8074d20a7dec83728f64100edce5c0754ebea1e39f82e9333f336c68b8bae2b83a21d0d6b9c01ae958bb5afa8c83e56267de6970b60ef9c3ac73
+u: 163a7a58d2d07f959b1b7503d431630ac7cf1e955ba8e49c56ca122d9e7e172e4c0bbb047c70df6d3382fe31d1c98d2999b2f7e8575e7135541eed147ea68753b763f0eba5507ce550e1ed2e5a867b97ee901c416815bc225fb86c371db2edfba60fcc04dc3ce669998eeebc16cc4235e9b04018fe1ca22ee386d8152582cf06341368ca6f479f5cc5097c4e33fc9574e0e8a47a5a583fbfa26a49f704a6c92229f94ab5924bb378ccba85cfd74034afd7bda27fea4f5d1207c443e727855d98ab9a0dc93c879f37f42dbcaa1a1ddbc3767ac773e34000db0021a2c0bbdf6c44c55d8c70e23dd96f4ef059e43c3f3bc44d07498fbb5156337f3baaccf346394a4
+c: b4ff4959f2052a1aba86badb013b1b58459fd3b3dd4b8c617e932a4c66d052b128a3e66f148ad2afb2268fc9466f68f7befbfa14c4bba2645a42bf6dd250b662c5de340d30abc74fd3967f4cc28b9bc979c95b2660997f54440f6a09b2be636d06207a421a6f10b99527504911b9c86cb3cff7a98f97b55850b267e825582bbf1c175356dbf9b7ec6ee6598b3ef2bbea55ce595422f74284b1d044edccbc4cae699b110b6db782cdaef06a04ecb652570177aa3d465a9e004b459ea9236195363c784282563abbe9d3491ec7977e4d250916d2794e2f81134eb2cc6e8b3320d72562e4fc22798ed994839dd9a4588f130ba606a74ced3bfc1659c39d67ac6330
+d: 9c836121351fba22956839382e0b9f01fcfa7b9abf30360945253dd6c25052fc355b1d2f23b3c2f0d17c5f8ba79bb1f2159e8de8c52555b6456eec1aada9c900a7fce538b9bd8361d0a415b28e569c6ce6744e27a7990462faf28f98297be5f005a5a7036587781e314b763a37b9839a34b71717d33bf228037e450ce0b6006e3564ba61147a09c389eeaac9e2c85195561a3bfa1795da7657e710a0c068331dd9d6b36ed78b38083102f05cb34ae628b0295558effd3826a819688027a8a7b35bd255e09cf9ae1f333577fe5cfd8655b873e286b121396f8cac69fda750ac787631ae32daa6f8438feaf137713444539e9d4567a6c2e06de7d1165c61d0de49
+e: 1
+h: 200
+k: 20
+l: 39643844472340465e42372d415a3450483a2b7c38507d322721774733694f3f4e4b7b313f5e7a512c5a6265736b4e792a20392a4f62603f5b347d34252c312567367969562425464044693a
+m: 33387c9a738ea192ee758197b688fc109d95004f06fd05b539fcffabf79fe77d3c9ff1ee779a1fdcaf18904035f10eec013f3ff16e3b59a418ca9ebcc4
+n: c00496dd4f4b0a033a5246f9d69f4f8e1d9bee104260c330200b3588e97a00fd6157c122c347f32db73fbcde9ba42af2931dfe259d739bdbb07de925fcca97cd96f841b35db96545c2fbe29199932e1845be4cea9016ad566a9907c807f49c57fc140ddd470f4304cb55f299644bfbc80bedf1125291fd6219feab9bb7133067bd96eddf831e6dfbcb613e4e899b9b7828d59058731ad8a67ded081334714e15039bca7fa0ad9e58c02557d3060d25b43771705abce9219861f60557adf29861d7fdc39ed4f2365f31495ea2c08efc665e7f54909cb2f0811d630fe41b57fa9d982b79d9ccb53f07999529ba0c036e195b8ca39ea04cca0d62f201e5b2d36363
+u: 1554d2ce15e75289c36b6f608681ea9fae2cce33207a64910c5ae0f699b7603c7cf005c7e95a4161ae315b8f7538de0ac314cc5df93d4d5396ffb9589a91dbc06f3c77fe98e4b0d4c79684d2389fcb5ff6592dd80e18b7f61d0b1fb5b722fcb16ccc7cc9f86da70cb4f0870e8376eb8688e00cb50253bd63409a00e5bb9f5aa355c3bb13bf225ed34bafde84eb222c7a3ad9c47caa36023da8b3cf80199198a3d80630a4d07dcac9b236f5a37dd036592e5bdb38934b6963fc11e9cb2c3e8d683d2385400063caad390ef944fde49d2a4ffe837f1bdecf0b96ff3b1dbad31bf137406923ea9b6357fd157dbf8b2815a9374b23a186c068c2959a443a60a9db82a
+c: ad76f79cc8d2c15430a094f4b1e48288841a930e7ed33c7bbf8a0c6c6ae81c5bea9652a66569d8384667911a24350fbaadcf11bc6497aa79fa969cae65328f399a98123cf172f51d772a3224c7c721d8d9d8e7120130bd90b8ef5cd99dd85c2c1b309ed9b752505695287056e2194dd9af1424ce64146b9b173b9ae96f8f966b66cd93a26b381d078074ab29ebd3937466b6b7234c6adac62d77a3bdcfcb920549e6a475f29b3653d2a13898a6c830100639e9515baa3f1d74098ce54d7ec2e0dadfe594a6a2ac341d91578e82e0ee741b83973c961e56d3670331ee5bf9aa84657a239dc96906758d198ced041d7f24c1a24d34278b415e52aaa58d9f4d1787
+d: 8ed5818873ad85acdf4ddf51dfc218435a9a94bbbbfd90af0ed147debe28c4855ff89f1a7ff3185206ebd42aeccf9300b21e2770c37be3002eaaabe0ddb459c3574ce2327a62bdc4ac7d7c9ac06dadc30671b9fe47636e6107fcf857f469a439ab0c62095b3e418116c3fece1c48389d6188a6091d5ad1b27fff8b5002890c1ce1f27026709fe94e9f93693ed68eb1561f7496ec8df621586e30004d0bc26faf453d9aca094d71d0ac290e0acc557e310062e9829f5dd0a45bebb3af052d0093056c3a2c0ada033058ba102e8a31d47073e8523070b7561a0e1692d2441e3e54c0c821add76fb7aa30d50c00894282608b495b1cb0acb3674f70dcc892d2ac81
+e: 0
+h: 180
+k: 20
+l: 
+m: 784c7d5c8ebfffbb4b9a5095cbe293f44b79ac085cc74a883f1b24247eeac5bed1bdd2c99483b5d169674d51ead44c69ae78156a47d794bf8fb109ed63295e264d0b156135d61296
+n: d355fd8f8f4f568e995bf7d08e56c34fb77d3d43e414a6040af5c338e4ea04ba7f7079fd6dabb074e1ab03143ee566c02a589335f69e24aa7bd09377fb38b7b224d4244abea3e2de1c319265d19aa987bd7267391938683e2dbd4e45aecb77aaebade9d107f64583475084b6013733346306f7b8e8684dd8c732de24076769671f40864ffe01b37e90f9852be6ca92344ead01773e0933ab1d62df704ae907d515a1206257ea760e78e2e635777b44f349de07c60431b42c3561bb007147990e3b0d62fb2c706a77870ca8792da91a04effb6063f72ba46237b15e035e30dacddf60d74be4f12962c4882585301f6238c0b159062f3d7176798c42cfd9f147e7
+u: 1361a7e3f16eae86c06265d24b524ac75e1d91ce97ddd7046807042dcd23f48f5b0c1e321a7768eef9dad1a72e31cf69426270b821768c8dc3fa6f95315179affeaedca76fd23e6410670b3c046af786b6038cf3d6bef663f971f2ce1d99dbfb33751f70d2ad43d5265e28d99bf60110f127cd762a05ded43ce5713d9405609cf9eb2bec0a6c0e917dc4ef8d9d4dadf9b1c5551a291ca18aa3f18c58245738a28ae7e625ef660599cd8be408daf233b1e591e8c10326730941c7541c16fadac8b4a5084e1b42c46d853fd6740f3c1ec879ab3621d95c5b94c243336acb3f1fef988d7a5130d0c7e8b64002da2642719b8e8bf0647e8eb0117c8568522eedbfec8
+c: b1dd1f74de4dd0afef49be5b22662a9ffb62ffb424a09b0d60dd0c0f37813ff15d60213ef5374a87c8b73cae5a1465816afc768b20316c5d930e47359674a1be0f5d985eed24d7cdcbb5d3337d536659b126109577d02dc36c7ab6c19e4bc58ff5bab25463d2426b4abea79b69b611660768a7810855fe166f125c6ba21d32f511a90cd050a42a2e10e330ea35dbbd574a8bfdd68994c2bc5aab4636ce044a54f3ffd451bd5ce378c856c2ac5252ee349b9be32c1141d705538df7592fefdf77b20d92e49d4b04fd827e6d2d34f40994260d7cc36bfe3266dda11f0316ad4a9f0473eeb711fb459b0bf25f055c4c74c3418d2acc7ddeb07aea014844d3758091
+d: 30b8eb86489b28dfed544178bb12d60cf543f6a9ab9e9ec90458c0d089feea03fff7f91897433120a6eebbe549828d594d6db23f056147c24fbcc73b3da21d8ba49bd1fa8722a0bb375ee4e19e0862358519f45e66e490fac807838d2cb5f6a03433dfb7e5641692253c78c7db117ef9410ad718e092536b0093e86b464039c4d88979679f4709c746c6dd535d4e32d051f0adfd2eae7aa6f2851c8afc750dd7003b056332f7e88787c30af1f4b5e8261604b46c4a7cf13b354d7a69db0e1da46818f28291bc440878137924d9ac214a7a6470e2fd6778f54b5265f487ff668e32bbbe9f48ffb662d5e320dc07d868380b065b0268670b5896fabf9f264fd119
+e: 0
+h: 180
+k: 20
+l: 
+m: ab37d3b66b28a1ce5a7ca1391d14
+n: e4e5b05747ed3c49141462744896f0fc2239412d4bcbc79e48308ac25acabeafb1d2ba8851d7b5328a5b70ef1b1ec5c01d7d8da5ecd8c93216f585572f30074ca33e2f50e04606a3ea4f935eb5913c7be51fc64f69223db8be03a99d6bffea1777d5ca68fd5207873ec5ca46068ecf6b6db49d986b607d9ecfca2396202468c6a8e36f4e1c5a4220142bd46e4fe8a27d9362407cfd24f4c6a80791055241131d150338872989a28ad889b58b72210c49d0afb0e148e805b0a86faf9395c7e04aff27d441ad77ef073187e1c825ede9761b2fd6ddbaaeae5ba248d208e56f7a5169b0c4e998cc437b81005466ab8b87d67046bdf826486973f626f40da3e1c4f9
+u: 11e4fd919067d762c4def378f9320374b54640f05561e5361211dbe60ca0c8002869d0526e15c22ba4025d0c69b3c9ed254eafb09dc091c38fccbcce24b070c846021dc5f46b43fff2227537a021992e3c60de67b04cc03b733b9efe228f7a6aa0f3aa848c55b3bc2cd4399c9a5f0328c76bb5c9e03a49821ee0247b05bfd2f5384ea771e068b923b64b4175e86925db8fe113458cdad7767d3821607d8425849d061ddea3658ea63ea485ea011960a34ec96bcee72fa5f5980ccd5ea8b0cf927b22608c7b1a218bb386cb8237bdbf206ef49f54eea8914be16d85a5b9890c694afd45ecadd6c9c8c8cecda7a871b4b43e5a898b5128d3744893d6c89b8f0fbbb
+c: 603500e572f718f366a4a2af0ebcbac9964a95c98955f79a884161b1a3c9416854d20f4da69bb081ef45687a7b229535967d3a2b5fd17ef1ec9be4b27d1d53fd1943e57b557a6ed3d581dca78a56b3b9ec4e347748b8dcb0bade02507a870dd43ff61a81f28e8d26ed4426168f58ccc43405b4d3583cab6eaec084de617638e3550120b51e6820d216194dacdebcc7f700c956ed67e5601d06faa4506a2f8679ffa76c76b2b5f45241ea95bfe702c2afe88c8704f622e54a18a958862593bd5f8cd815dd8e109f954c343e0d6905323dfd5f98c994a4bd711699cb6da65666eff27811e30b5d838ff6a499fa0db535b197f5119fdf725801c989e7813121a1f0
+d: 8625473f0657a674324cb8b6dc887488d66d029cc59964395b30abf4426c24aa5a8e28b0f824a3cc6890b284ba40fef94d9bf026fb2a476dee23a4b46d339846f989d1d4d46946638ff6430200d7c59342a7850838fa2d676e82b6d8c61ffadf3230b286830ddd6744332b887b8a4c0e4fe16cace9df1f5a944507ce1cdaad80754f26811e8a1e1d92f0734abed1c3b64b6b7497ad8a9d656a45cab78eaa7d8a6b8c0dfb925dea62df6a65785adff2144816509c1ac87cd23ffcac0be407c5224367025594a6ddc53b74c5ab815c808b136b0e36c0264a3d894b521142b0c841f60a092bc524216fe5c17befe665566f6a7628e97ee47bb78115353794da4d41
+e: 1
+h: 100
+k: 20
+l: 3e4e47655e233d7b6957272f43502e
+m: bc58c830a5f8d40b9fd340f29637c3df1c778f32f5de9671e01ed689e9e015a3294aa22dabc58659761a64d9cab284b5ea
+n: cb7f5fcbbec33829942eaa2284b4f3b7c5a1a5653f373fee2c133dcf6057750be1da735afcc62d596b94b16003115e933e79bf3cf27c317e063219b7bdf6f45167cf6dfbe397d1e744b67af26deb649fa98080777307f761bcb8948a8c28714b27c8c0e31aa1d2060dbcfdbbfde21bce8843c4e037d1e1ca0cf688001f56eb6a886ad3dda258ad5e1010c82a85ddd84de4efc0c05c7360f642e662ade8b3109a36fd1079909e172e23804f0a740e17ea4bff1b0c032bcb4afc0a10750f0d26d677f4e1338173f99a6f0310ce1728376cbc134d2d9934f4f722eec66b3e7fcf94cc41146172ee2e29ed6d64caa1cf1dd3d184bac975c305a4cd4f7b4760845e75
+u: 1420c4fedac601259e274b0455baab36ec455630cc03bcadaec5414e30c33d4e62e264862bddddae6eeb548777ab3d5fdc673e71fa2b974260c497d82d28cbdfe42472e8ec093d44fdbe7463d2b4c3f46ea0c1d156ec2e6a64bc04e9ae8b124462509cf8e8d7fc3657e36f252aa4f93ea4d85633d73a0d17e096c056250498e0ae614b8ef653103d959d3804d119824014bd93a2a42e7096a1b10aaea189b919eaad2478415b0400d2b15f991c7a71604d385f7fd74bf9c8613a807d162acb5a51bef0923275aab84658d7ccf5d31da52c6619ec682e0d94423f5a45229682da0aa1367937c8d0526ec6ed1da541fc28d9c6818a4bfc9636e2da8ab1d19a65f2d
+c: 3a5b0c852f2f57c0dd496c1b873f6f7c183ff844d3a12ef2a16b66ba4b87faff9ab8b8c67fcc0213c7361b27b167de0d0062db620a98909104d649de74189895b4132caf51fce48a35604192798611bb904f2c33327c548452d2f00cbae4c3728784810526995f5183512802a0936216f1fa9596ab938cc183fb79dbc88877ea7d864fe328a2b0a1988596a67569eefba04a1620e875a0cf5eec5fb56c5b9c7a30d83b77e7fe5f54066cb9858ff5e080aa499a85801f0d42a7e6ed08c00d2ffe5991de6593030782c88b15fe193a37da36d181138dece1051db0e9d11c452f10b9108a746c1cf95aa13be40a015cb65d93de11cb9d328e549aaff84cba816792
+d: 343c594cac3a8e994eb47085ac5416fa8bde084b9c282e9197326ce22d2cde67cadaad441183b4097c09e5d83b4879b9e13435872439327e0e616af9d5a5a8d222196a6125793e77320e9ceb18d914c17b6273e7aa10d10e2c7bb37397c9f123104342b8814bae57cfae523c729cfac896fe54c1ef38c39d6629778b2e5980ed398d6821c289b463c264bf92aeb2be71b0afbbf62d030fa920200ad9af0cb78286e0d087e786dc2154ab8172ae9bebb981ada90f6c7f26f631cbb16d9cace8df0006db95190c736e5f82058061ce936b79f7fe462cc08dc460367d505b6c5120553424dedebed327544400345606e2422722c1662b078379a9d2a7ad3284e0d5
+e: 1
+h: 100
+k: 20
+l: 262a445d4036272f4b796d282b597d582f50635e5b39684f4b5b232d4b6c25692e652c66492e782e4d73447a3b3946707d52503d2c49363d704b22243d364e3a7c6a21253679492e5123756a60304665242259222e735d7c31375a6e57324268624f3e352341625d5739423a2f6b557c21456053
+m: e7bdc940e357f99ad6dc87534f049cd2db944e45d769b92c9f16975a3f1b27ab5e13257cc2c8547e538e880621b66baa9e10d98091c81af651be0fdd4dfd0123559dbf5f573905d56d36a91547ed2d15dab1314c54838a31cd40c8f2fdf897ebf0eb91d3bff97f903724ee1edc7ead2f9dd35c02f97dd6f680f13a04ef4984de62b40519476beb83b8
+n: a14a28b4fc438762c908a9a7a6491b5fe8c0bd9f6515334b32f57ee128fc1335a0a0140e064b10554c4dd786259137b0e9de61cf139a86795293b7e9b7e449f502e08fe5c0c169d7bef076fe26dd0dc4c7ed2d06ab656995848a1fe7d1f1cd926daa2f1bc0cd2223a741432da97d64be0ef790f1774838855edf4637624b9d85d86aa4403a4de260bea1e8ae11b1b6f794ed2d3c4bd9bd24a689c6837c956d7452bfb88d4de41905f1ddfcfba819f34e840ca78241433bbaf0b140a89b359657f568554c30800df2ee86257f44617e07ca438432582d05f6c8ec0cf98a57241c4bc700d16ab2e2fae393520e017eea4e9b920e4a1111ba7e1513fad46710eed9
+u: 1965326b95381d0dc1887d727904d3b85facf9286909b5e01815e0ee13960edc2745d31b6ac936f40b0aa374e099891518cbfaa3a5327b6003341dd0350d8361dde6b568abbe3467d0deb6d527929f27788063dd6abaf0d8820eb92c10b4fa5023846b3fd5f45a2020a1d32b0fcfaeb0ad5f7b7746a48810a54c6dde1ea4ac5ca1b4ef5fcaaf34cad9b0761a682dc6e6f07666383b294b9da795abe5519e9f657eed0855505c2a1125d8c3b9b90e4102b1278778a892032b52abfff968f3dac0dbda2875a55a9c1e9454bef9e8baafe97a37ad6baf3f52c00612b1442e91821e30ecf2c102faf20b6945e488b7fbade58bf8003ef38a326f58e200492f18e6e49
+c: abd0201a0210ce86391a818bf2a5ca538ee8aa3a6a5bfa15c4b8cf97e54245b6ae69942689fca094ec08bc4f06c96a46ca01504ace911224155ca88a6bb15f5266590531ff3f5d2180e6de08a87be1ba05db950b2804625c222721abac3c7f576d0897b794293730a476e1ed7ef36f7a8c6069f16b33a474275156a1b6c40c9af05d55840a042c0738affa2cbc8edeee31bb3518f83cb8d5ecc15e3b0f551dffa47501f1c4c0987ebc93409b3b16e3d321afa22d3b536c0999efba51348dea9223947ee4d10beea673c2adb8c5b545ae069c2624689777384f9920e4a3328c25a9ae86cfe57355ee1766a831a6915b2d1e10d55e059af3d7c3b1ac5d04d5d79e
+d: b34b393ab5f21be55a81d6b1e5f4313bf33d839c031e45e1e4f7bc8815268a700c9711849b58089e60eb8b58ec205355bcccf49e1f1ea42b4e36f32fdb276449f183bca2bb242b7726e69d47b54b5a0f45e7fe52871c62c7b25d78bc9ec3baf5bf117123e35905a0335b80bb937a43ff3c3c72a6a553ee5e26f6b6220501f7674610aaa06e7927c6d1db9aabc6df823b9981e1d54fdb580facb9d8dd64e65c189f462e630c464fa6fa4f14129bb39509df28b32b2ebd307f48d517701f85881575202aac07257a00f93a42ff25837b24110461a0208de69ce126324f450ce1e10da778d26a1cf925ed57b45f766662745914a8200ece2016cae0fb8e07171e01
+e: 1
+h: 100
+k: 20
+l: 7740552d2d48776960673d233e6e452440534f7460337e75327373397d6f394c3d6a7a40574c2d322a2a74532e584f7325384c543e6d6d6b2c205f7e7c24664e6a76704e58516f2a24705c6a
+m: 70abf9158e1fa08bcbe4458e87fbca351e95e0a3db16d9f9a35b16530a57294b09b6d0582554c9392737e09a78bad95a7fb89c45aa4dac6161f13c46264ae16c7d898382226b8ffcd8688f43a9ff
+n: cab460f8a5d2ff77b9cbc9ade0efc7af538fc084deb1ad9c8f20dd05cd308a97bcc36fb19fe354655e3bb0e1820dfcfd086b9ef66823582813168befab97fc8b278f25f909fe555612ed4b2cab14a138bd5450cf7b15984a250c6a1ad02a3a0dae7d902b558e22e03e295a9df16634f74f54ed924cfebe940e395ce2a79f525dc4b2f24ec56d73793938ce5f7c7bebd94aeaadd80ae0205661300213ced5090e5021c9e0e574db8af5e7b1a99e350e0c66cac22fd2fcb125d4b07ca4b7d566ef711c4a3f34f5433cf02a768c0073bccd8074b955b5fbc7e1309b92642938b30f344567a5a516288e150bd93c9b4204b0ea2918cdf42843620c6953ea098fa4b3
+u: 1434ed2844ee279b1eee3cedda5e6bf7b6ac413a40ab681d379822cfc1485fba153c228e9fe7a8d18c91b606c2fe4f2920417be96ea8c9f815278bb3f7e756e80e9658aec624239e1b11d2024cb457fac540a49d7de0713ca59b48965438fc34df14a4ec0f1cf5206beb5526365ebe31f4d1984c97ccbce98ba96019e2dd57a2f12ae88b10f95d2844511ecccf3123d64554d72d68839785d3d311be2a805ceea1e1ee922923d07c1bf4819c5e849d1b04691af6bb6977217a48dd1f1d10ddef37eb8d27b38d417a54796b047c2fd2919c9668095640c5293cec9a043176fe392a1b8e11351bdb66744c79846e574d8b7dc28c0fabb7a8aafeff45053b2972be7
+c: 3fcf7a994198675bfd2544def884322816eb3f527d75a9fed471e9a8e4b397d988ef4d4fce050c3dc9d6e182bbafc0f98554506248383928ceeaf74cab475f1c8bee94d04ba7b8d2b6001a75b51a0431d7ae69294896fa4c5d626348649c75754b3925887cefc60f3ffb077ca79d827dbc2235ca9a805ad65efb9b34533ae04fdc2e2f08f857c61c3a9db871e4c6f438ea5cd5915a84f63af2f8d59e8653aa102f297e3a47be56d4ec4234e2a8e0272781d8b47c3db74660ccbf3774dbbfa81502c1c29dacf3f49d3d718080d22668b5767031101da584d6a130c35e47fa08469a028cc79943adc2d4fc6bdf5275b7020522c09b296c66dba9e8912adc56480c
+d: 879caabdba131ffb334a6b4aa3c231e6485bab7be2b2b1bad057bdf525d05780b24e95b17085ce83d13117106c70d5125cdf28c79df72f1fa9527d8430c44b918bbd86bab990247f1d98b5a953202095f24a2a934fd3102d8d335daf6532951108863dfda19d8255c59f451607643038bb859b597ffa43fb22075572ad85dd598f390cc9a72ce7d74d07c1df779c8ae8c492353c2a7e06cf4da93cb52baf6724a6502f8553b110415a514b9beb11ca5afa4ace59c171329679e5e09f790cbe0600d5e71eec8c6becd13d6f5fd4529a84de428c643339f47bc82498168567fb1dceec036739526f58b9fbbe07da1664bf5237a7c06a525929f0b1f7d9f4f9245d
+e: 1
+h: 200
+k: 20
+l: 43217b6c3c662d3b562a732c6a7652635e295d2265464a7d7c3c5c6c34683447604b62337d7b5b645c41503f302152222f483a6f26482e4138322a515558363152575c6d4631624635335e765b225b2a7b574642695f365e43295474262f6c2169313d6e4a30475829717d6157214f227e477d
+m: 602cc4c7ab00ff69be5bb343bd0319131bdf6ee47d2c11c62c127e7278faab3b2c2339d1ebc37b5b593234913a11419b28a0d53a85a0779914e6d891e4a2252b85ae16df0b58e71915da9587df207b1dd14af96a6d7089f872e104a4bb5845631fac1a079314d8bbca7c8781541c79f788a64d4c84117a2230d0fed8fbba
+n: a729f47711d588256b36d25f88f52180185aa80845e83ea906d5ceb548c6ca1c4ac88ba2b703e18ec24f3f2ced319b55588cf8ee33d52bbd26841bdceb4d75f65b64e91b15fc172a91ec4d91f12fb5eaa0236c65e0c7ff1df383a6d1e684d1961152293eacd867e793f9ad2da74a076ddf64f3765367935c566e8a67247016938afe644ab55b22f6ebf8a7f95e42305372f3fa02738e10587f0cc9a9a6b2fabde9c81e89257fe8a338d7cc17dd54d11ed1a7af986fb55040d334e0bdb1d4643a53b4169404b09aaeedf922bfaec9dc9b0c68dcef4045e09d9026e6e267faf3b75d5c2c9404dbe12fa5c95b19897b58be13da85823d0570ecde7800a08b3c0f99
+u: 1880be0e7f33514c718b06decc7629b98541368cf9b786889bb5fce53d5a6d6d1e40c22e122409a22b22c0a3866e6cc0261c051fab4047142f410fc4ac4ddcfe11864f10d8dbfaf21854f08961cbf543baf9e9cdcf77ada77a7ca79ced4cbabd5854e9d5d242955909147c730daedecb368a0690b466553923e8f34a34b0ddbbc1581b1914ccaa3a57ee75e936a7d28c5250d4f6eb818687e047a5c13ed2029d0af97440fb6c5082c4fd5bbe1859eb8d9ffba1361ecc7726e8e7ebac1c6dcd6b8d7a92d8dca29e1f47b68111819aa45e34852c8077d1729bb7edc44e59c7a17067e9e753b8ca1b37c11df6c641cb0f458027c92b36b31f22a8cc52dff82b4e323
+c: 169fe8b98939084626881bf98be47cf294c6843aeb1532c2e403dfc41011641d206a7ef1d4034efc91ad2a69b415d2431c9b4195b0c4d0fd67a724bd0825f7028a85e11c8d3fe35a7155e4c968540d0c2343cb8b10f92051863ead7ddbb66d3c7095d46ab5589ddd151549e536ac16e12855aa986d3a5efe9bd9da2be88e9deb4f2cda4f9c5603bebb7ae97f70d91875c0c8e081e224cd8dc00e9f479b599cf6af7133209fe1dd12942182154da42e30494c06266ac70443e306af287a7c2063a41b81235bca02cbc8b6916de40d24bb54a4af2c6e5644f7fd84e44bce4f26fe0e3bd722f40218c5e1b85252b1faaca663aaae567fea45b228733dcd59862680
+d: 434e5efe2c9387e69d344283dbc161886df2339e85cd2b3a05595476f177d98f7b8e24f1a0b9a9dc850ba9d26d1adb1edc204a0e427d3a92210f0e0213e937464f9cedc38d521c372effeb68b35ac8e7c734597902a6e9a7a32be9446bf09011b2f79a9bf552ad70f6fd938364610de9c4656f6fe498092d49b64ed23561b2c2a5e0d52d73918b186a0e9490fdfd9fcc572128e725d832dbae46ab9fa0f657890ef184b1b5429cb40294ea407d8a4801199f165c5acd8e39ff1c0f1d6cb52162e127eeb3fb76f457b61fa80ec27e349a225642d2aba56f5afd15b94cd10b91bacaf3c72f919c09db2ba170701b7d62b866359ff4f2d7ac436e927f9834d86801
+e: 1
+h: 200
+k: 20
+l: 3c51576c2a6e3b297a3437396771665a5e5076
+m: ad9c6ecea2c34c018b0f7d52fd798ad6d9ed6ed34a7dd42a0629a4af7eabab2e9b071a1aee2837d9f4d4fe327222d9749e934a2f
+n: f14a84742afca8e9e0322f5ca33e51f24c13922a7369d6f5446d3292240744ada90f73f5f0d6924ff1ffbb695cb535ba55e2e0026a8f709812f30fc51984c8eacc059ee7dbe4dac127a1b495d241cae7fc3fb2a9c0e60e3c414e77e75085422bb4adc7642ab84c57b9836e51eb6bc30a2f595acdd353d61ea7005b88ea87fa2183db41ee4e3a3980299eebe95c6fb8097c138036727ad41135285aeb14b7a2152d0a5a81ad3437a5571af8c43124b630455390da896f0b78c1956ea624078dbcdf9dca41eff294b63a69a849cefb3bbd0712ba3c01160e58f6e4303bc14c064fa002c11b06c1dd3befc2b7aba4bb6c5856005a5f88093b9831fd6bfe717bfc0f
+u: 10f9b0603452769df83282bbaad667e03fbb4a90459a706459fccb6c98c961d6f51d0a18be67411f5410737734d81627ce342c4dc49d28949568cd35cf7bbdd947d4f4dd7a9ad8792e1343b98b4076d83732bff4d07d8139541c4abccf7ef2c969aa467fb8301b82b606d04b114be83b7077391f751766aec48ecf3d0b182f71fcc37ffc89d64df6b4d3515e5e1485a04b10e2d18153faf6a44c24619fd943d2a8dbd236bb91adf5b7e77543366425a242333b70c26cc27850db73fb929184b7d74b6a911efd011f78e6c378928f6609c8d10e91e60184a31d139ca1f29a06ba5aa0f0335e61ed42111860983b5747804656d60c846aa95f062438d9b877445bf
+c: 84e803e848f0599e34a8f48ba76bd8eb5f2926f315ece03bb6b3a30e274f3e6c45e16590a1e8668812cb30576687beef298c2277859988f448aab2e849ab0c19e892c093ee5f7fa8f1e4040d34f35176fdd444a70a4cad064b162e64251ccb60b8daf769e2938ad5083eefcf6eaef75b6a567c28f0eb75860ec6c3ab5887c115f8745fa3b5b5bbb4d60ded39d917b6b09208a8d74fbac4c31b8e629942ffcdaa42e985bd6726bdf57222c223aa78912696cc3e9211e9c09ec9c49a1f8b6cc1146d6293ad9960ef11228764d22fd7a72bdaf4584c3431f1cf74740f93e92f5e5f5cda1a2007e7a9f5ccb777911944210c78ac54ada192dd0974e0f6610e6d9312
+d: 10333269c2dd2625cf84292ae42f667a1dd40315cb66b5a0e36ea6483317a37dbcf43b93cfa7cdb43dd0c5dca1e484ebc3e902f7f266a9e71ac7ce63eece50b00323e00d42efa06e107c0d4d93a4fb1a66bfc7d73f789915d5d3e833208c450c7b56f5173e12d4195b84b88bb0fe1d579d6b7b234ce0d465981f62e47960a72316d28d003ded5519e1cbaaa7e41e0d4578ccaea1a5a497d84236ad9de86f99cf119eece2889c706abb9941cf814805b676a1f39a478fd81b31b290eeb2343767bc778e197866c86ecc3627ac5835fbfab1b3668dcdb6a9723956890dc7850782c6d56b9b4ab74450fdd2f395436f17f1316f302d5f3de06b58067e455d892a01
+e: 1
+h: 180
+k: 20
+l: 3b5b7b6b2d7b797e23725c676521705e303d7d394344634f615f29616924627b265470755c62633f4c4d34682c7d775946402b
+m: ac95d3cb338411010d95bc29aa5a2bde63ea3582f0f5b0fbcfc6d77bc4c252391942bd1bb78da38f291f87d56a31e11941d022bdb2c91d22ee32f33e24aae05a167b378a545a706ec9a6e7164ddeee493d91fd42b3b3964e8bd95a91f3a75438480e75e7299dc173c77967
+n: d6eb330ad85a03e271b218692a32b7521a056fd2517d76571d9e3fc8eec968f5738fad807a7ca674436bc5d3369386f578ae7a59696ff3727544ac3e0a7b1a3d240feb548554f47ac2f5ba6f91db09b5e317c3d6179f6ed14dd2b588a423f18760fb4133c74f80f14344d2a01b0a7c413b3cc39dbf203214f683fdb66d4c8409308be707f08d3f7085e0074ecca73b4d95005321f52abc74d430ad506b476fc1fb8ea8b0808a2a604021ea3c0a32f3e314940ae89c17c18976e2872e3450f4cefb824c9961b22c01bcfc02b993187cd783920cc2a3b5ff9eacbce79d6cbd17727d18141d09a2566dd3a29ab1c27d762948c5feac13f11bedf9e09b3cd9135735
+u: 130ef10721318218ae0e6da6973c6b0d663d9bb2560e8a8429ab1347df0faebb56b1fc85ade0ce8c5f9430771123220ff9640a45ee56561c5543c5eeba3b09757f96309149fff0219fc2c332a42d0af8004193aebacd7a2398b354dadef7b602dc59e6f77ce64603598db0bc3b17fe829ff11208d6cf6b552d85d949788ee98eb0e864ae3c39e0305fd5e15e86eb409d610908588a17aa99c937e474e88eebbdce95092ac7b8263067d634cc843954b95975fce5cd8c0b4401f827e0e0379b3439d2d6e95be63a8e3a730b57a0395d534152a9fa5c353f7c1f49ae9662ef15d07ce13d024b28c7ed3a1b07f94a6380f556e2320cfd9cccb24521cfbb75b86d239
+c: da85c62badd9e13de2e85a83e3a673c748cc4ce019cfdb9867df17af686dc0fb71a4e7ae3aa5ebf38cf27a6d39216bb2948706cfa77b5e047ce4e6e1722e422bcfadcc378fb4e7ce5da444ced3b0c80371e580b497b942a3fe7efec8a2e89f1bb45539a3a1794403cb09c5a6c84e67bd81aa830a4cac5df086993158a8957a36013636c5356c58ab4b6b390c3526f1389e3a4609d2de5c4fb72b29c1ee43c1c40ec1ff3059e16662cce1b25fb647e6d204285c797229573851ffbe58c1cb970322feeb9a51451264cf5e81d0c4fc338d8377eaf9022369d25c79f820cce6df90c5388460a030587776fa6ed371c85af61d2329da59da9fe807d4b6d82c59cdde
+d: 27d0903c4f4ad18465aa04d9fe58838867ed0a46ff813a56e3471a17f32379db5d2f6663d966841178a5b230e86619ee3e25d28301fd6fef81f745f8b669c2d45569acd2884250d676c999b1ad929cd0b9cdcd21d111b2a3fa43b754634a221e8b0c3f8a3279931e8f4f4654912c96387ecd006fe4dbc3ced8931cd304a03bf9e40ddca1465af586828a413cc1a30d23bf2418d033ee7f8eaab12f4c5248ae779e271d349b19fe5d3dac3c2103c0fa61de2af525f1079a209ca1fea0b5c0040b744be1d2f1cc6b9901ca870e264678d9ce04f9abb91dd8d4215680ab98530430ace53a92f1edd0a93e4078c9b004e6fe57818c5b2a232bd7bcb493634a979f79
+e: 1
+h: 200
+k: 20
+l: 642534255434624e2d286a2a
+m: 7ab820337e969138009cc1ab1eecc5095e98c4b4c4f6bd
+n: dd5fc26ca09d16979f88b018bdf6c9dff9840883bde48b4383fc350f6ce8538c859664cd74a8eae92545ee609e43f1960ea3d15daf2c10dfd50e9d8c5573c446761056720c23355631a6927fe8768cc4652d857438ce529c8690344d1d86f842d51f5a61bc30565b66f727119a6c9fdfca9aaa40723bd402c9cf82af63b1e9825fd467ae27b7643db865a8428acfb7db4aa040c2c6d6cb45b7f37f0f94732866bdc7c36e5f0884b81021dced4e8edda5e7414120d13f5cf1a1f1b703f8401b5de09764e4efab34f626ed0950a7d35f8505013b5edb15cc57ce6fd37ca62221e9e3f082d7a2b8ec74711124d047d06314e1c35a5a42f71aae6ac459f156e93e83
+u: 1280abab5d28f92033850c0576ba054cf14dde14fbbe8423770393a341947c971b0c54481b916a5efe61c4a4ea8f2decc531786fde1dee3309e77b144b7fd35f8f822c9db9c7d54483089bce73ce9d948d6d0ef9d75da580165440e1b4992178b988e02009ed68e81205e34c4ea8f375b7795947ef521923783f4098f607a2ca6d7b20b8ee1e6099bb0ba03319202dfaaf41e6387824ee082befa5ab0141d9b894f1ab9b1c8a1dfb84b36ba8dc4eeb19f0d4e962098e3a3a9ab519bf5b33cdb70b85873ad8b80a34fc3951f0490f7eadf0cae4b0597e3fbb752aee382ed9a19b66c9bcfb60746963551f408cd559a5b535440a56bf820e7fa48099e69ea6501c6
+c: 5c99cbe8e659eb931b38b3861435fe4386be6b2961b49409cf0f959c052726c4e1f8f47861da8c1424acbe534ccb8ceaa35817a961d13656baceffc3f009d628b79617fbd64c8df99cdc0e61a0410e2eadc89013cb9ec6130e36ce536460527077ac15064a31bb78d120b1198b0f250f25b2fe44136ae48be0acee4473bc6f36026e8e2ed18616db1221b5993bab935ff58a8a379b96ecc8946e5367c149c8a046ce50d894f6d8b782b6266da14c20ee2b93cf505bf24cd527637a08d8363de23d2eaabebf9cccad7b7f4e3c650b602bc78737c7f69c293c176a2e97c3955512a8d537a081fdbcbeef22ba3e596b3211c5de55845d13ca5680c2e1cacb304e81
+d: 1c6a81a54386ad93764a29a952c7457ee7f2d54b05973f4f16b69081c67f3a2ad6bd6420719b9f1685ca565cf6e31d94de56cc373af14816a9415dcb177ecd222b1b707015d477764df64eb7e42fe746c49af71c75c1742d0f0c95bcf5d4be9d007db3b98d969d0c3f6bfd1ca2fa842e3f1d1656f7cb82ceb62fc6c74e599fcbf7ad298d482f54c6ef31b089a4657469332294f3c3623f873e5c9a288941ce614c929b56fa2050e5fa89d1942cb709bbd821b1643efcdfd89446e45354f2f74e46281bdec0c3d41226a049adfabf9afe67f86c16037c1ee1a671d027c1917a8e65139af246d978caf8765317820f370cdd0b82773204c98b48ed5bc6cd0d94b1
+e: 1
+h: e0
+k: 20
+l: 2a46682a4733492a3779453c396a6d462b775770786b2d545f7b533931532b394c775a5f514f26423f3e645d562131
+m: a4f343234bfe0a2ee7c9df30f5303c64a36880f0040ebcbb89
+n: c93e3092351cdb27e329fdfe76871dfe0c54af707324d1501d5e887263ba4e4a4645ae6331da108c00b00e5da60a317657d9c8ba8a71814c71c102d59979aeb20ce1642f4ff6a14cfff62ba8a9bd264e1e7a605d4e575c308e58fcffeec8f6250b6abb8a14087b91e9528209687d759785b53cce6e2b8f318ba8f0fb1b69adf1ef7134fbd4938f8937a2fbb05ee9a5b9e73f2644ea0a0a898a09d10dd28bdd385b5497a97d82d9d87da1ae12050dc3c72f6fcc51bfeeb4d75c30cf0b76bb8539fe7551cdc2ce7ab2b35dd0fb74f9c5f540d6d449859c9c84d42651915af1c9cf0e20e46be9aeb8999f8d8e54a3ea55849b485c373762d01bfbf1b45dbf345347
+u: 145a7fa4ed433b1fec6edc670a46e16f7f5d6f95efea38a57905afaffac1502d6083d4ce97849f4330f3e7081f330acd9fc0e31a7ca3510dbdeee2a8465cb1b9d45bc3dd6459571512212884742ed648c6bc5941f6e316b9e4118dbbb46b90d0364defc4a9f87aedd1a330058d096e59a013721999d63d06ca493ca30dacc0a2a743bfc7ad0ab8621c4d34c71c36125f81bbe1a256f62bc398b6ef2a14d8639a0459adeee409b5aab50c449c5aa77c3af0500e73896305e0bc4eb604660d0158f41eb4472021df9ae01b247179ae9cc0e921792091efea98cfaec3dd6357a717625edb04b1c955cb61246e6c3e717b5f85289db7c3e763df4226e77a37b7d435d
+c: 8ee3b2ca02d3f629c7a798fc97e7b45e57864df699cacf8279ab164cb683316ea072254a0b7abc190c1276cbe88d0aea9f464d617e475cca90c1c005fbd52a47ba87c3abc8191da602f744ce9be55fa618645f1f89ce5cb65f59c2ebf104e2d152334e6ab930402d25afb5ad205799be0a25d74ddeaacbb5a9c038ac784487bfc316f0dea693023c4bbe1b8b4e9dcca8874478c947c1d35c7d9fa8aaaf5fd54ed47612cc78f5c149ae5e3bd4f5391a3281f3ab1ff1a3364bf204e362bf9191bb4aa6e25c5606dc8c4fbc3201c3b25bf940ad97bb9fab7c99365dd5092c10db3cd9b030c7423347e2f5da68bb8b67f645d3160f92fc30fd07962c4fb6789ac946
+d: acb1f751b06f58636b41ee26c3cacb5e15efb0dcce4704edd819b022ed2672b74aba32e44962f7c2b737e280f5d6e236742c1b979723ce346ec7cc8191e99d0f68298968ecd550b7dcfd1a59cde14f974661e2dfc5060d7f6d9224faea90b32edde70f7f1859a0bb9aed9a2d17ea6447763116edf8d53d6b9cdb1415a3e032ba0ec377dd5417c5b71b71f0f6743e88e3380ca4284e4d5789387a34be384c35e2b7c3062e04ebef8b4a0c9e3717dd2d25a574ff754e806a042fe8d1c138254e0a325b06410a1a298574d34f7fa07b308854c85d0c31da6fdcc8c94c477de0fd456518196686d0973c20917f3f5cbf83e490e7b85b425db7eb088638433c0252b1
+e: 0
+h: e0
+k: 20
+l: 
+m: 4279e83d2757622a07775b7ff5cf1e620cc5539ec99c52c90189cf77c7339295caea35923cdc5a073f3d9ef4f5ab98921ef217a1c0847089637045cec07ab9c6accc851838789f1214523857c3e2d0a767181a31e524b4d1e56f5474b971b25b5a39b73139fefcf3c30b0be28a7ad8cc67cd300506c910ce0fab342ae4d1454d67f3f3c01b
+n: c4831ff5150bfa6df299a3d9ecb74de33877949870502a31e4eb674207c69b54a0e98aea167ce83111369e274ff2068366edc414d076a6422504a9fab6613b7362e744420fb10c2ce6b1eaf63b2aab33e17ecd0f511306ca1d5c74dec6d87e1759777e8541f4ed983c9012c0702feabe69bce797e1a58c192fa27bbb4ca125fc3db93febe66afad8068cb1c3170c3b18d4b9028ab7ef72d209267189c2de1f7ee0c1284770dbe636caea743faaed2fa7b57bdd38403066b4181eaa00da156450594573adf469dc0db6f430a7a8efd9375b89b063940ed92b84c4419314595cd893ded025dcbc878dc6c421b2f2c930c20dd08b7d6dc0c27c7f89fbb698a6a753
+u: 14d7eee41e00ecd139a204e9da5dc04d632205b523d1463feb884a9843c3d76ebbcccdd17b4e4883d11f1283034022e78b363ff1dac9d4bcb6009e586b09136c2efcb3d948f67c72bdf270d73264bc6aa07bcc0caa7eae4dc65ea62fd7983fd9bfe679862691a882a49a164a33042f927185cfee62270d06ae236b04ff91aebe00c47e411bd419bfa42b457655422818a8a2513f0dda77af3bc05f84c8dca567311b177cf341aacdb33d4fdbaf533c0d3c66f5f12813b8a465926e2f583faf8b48e31db0fa89b1271cf9b9163a24e9f66c4f5169278ea4c7cfb7fc06e2270e93c1c321277315243bc3a348b52b8b074e1f5f008f3e6a928bb714373b5cf398a64
+c: 6934b18573aa6555607653b8415481fa8ad52bfa3a690d779625850b71b9434c13c831ca72746e139ed3a6a03cebc4e599b5847eaaaa3636576682dc53538a4d84d8441d32708c442b97decaaa229eb0b3249e1daad600857d39bf03bb8cafda860d5162a3d03e20ee07cd51daf2d38e7a4dad51c618647628f0d77ccfffe174caffe4073eb25cd9b5c779fce07d5d75e901e339f6ddc853b630e70836311f2778552b70a6d553fd3b17b3fb755a1f8275442f727d818082c5e864a9b67fb300e00a94dfa9ff2c3458ff51fedd9e9debf3d7edf64c21927b25bf9001c673f241201970e1d0131d047407b6f64144a670151368af83ce61ab747db719e32d9b31
+d: 50bc2addde010dc16fd5aed5702699bfaa522c556e296c25284dcf3eb0f54a003b490a1844cf5a2450214053b31a9b95be07987f74c2f3738808f67b1d8e5bce24496ee0dcfeb01c4fd19ba339dbb5409d21d69fc528609b26ac3cbf67b51633486ee45401783b73eb7949053d17928bcb6094be1d95f699257f48d5ccc2610f9ab680348729bbd114c4973e0fce0dcfd5aa28079ed79d0db89c147b6c59598fa0095bab45efe3eb5f60c6255aa0de20406ad28135f3f6d09dad6cc0af5e34c95aabf7f3013a2f92c997f9af9bb67ba8475e2ae1092e71e5fc8d6790fdd98c209de6973dfb885c663de8fb401d3d5a9b0e3737b72cf025149410a67c5122b3b1
+e: 1
+h: 180
+k: 20
+l: 436469792d624755233c40704d277a522757546c5c42754e594a395261357b546e262f5755246c49373e356921643a735a62467a392959426771327a404f21493671523b36477a3c236d6d533a4a77786851376c2a3e6e3869377174735932526f25267e252c5228594f533f713a254b71347e
+m: 3bc623aae29b54081037ec68f3e84748701acce84b7317a158807b15386245a62462b5d9e484a2941be921367e546b90aebce8967d201d1b2c70eb057d04a68b3fa1e87c91f421025d2f8f43962f24839afcd5ae8a01c7ebe73b82d1954ac6f2109faa129c0e969d9b89df94a06743776f3ab03f0bf783
+n: cb2d463a525df99d7a1a5f11dc88625d45341b5d13f1b5b55f7b2b3d0c49a35fdb99e58cbd359aa07de1d85fa9a25d1393ff838005af9727b08973b3fe20882c832bc69d20381f401cc33951961909ee868aa4cf7ecad5e6f203ed2963d249cf3067eee26db54c8a3e0f7f53ad288e601ea283e8d2cd19c4277b8cd6d3aacf21742f26ce3711a0a70703ec6f185fe3db2b818ec3c2a9319c9d2d21f6ef48cf8118c611a74a25a889bb216ee37e368fca75441d1900c327ebf38ba6f82f7c018e8a73c246b31e89bdfeedd59562fec60b91bb702b8e5ffecbe3b9adfc98ac1a071647f35d2bb27fac0d5269d3d9952c903df990b07ab9f50ab307070c81ad215b
+u: 1428e72189a62ae1aa771a758d51153153c06e7640dc376c1cfa73c58b0ce882ee083bfafb6896b771f1c50ff5b583ab526f99e569663fe890084cc312aed8cdb05c7bcfc19e17f251433f44cd4aae38b6c8e2df31b3d9b958054b3b9a9505d8f21e83494fc4f878a45a6077c9ab7544f1359d92e04d466842c867a751a64dbda0a9269972dc9393da279f73d8552c7ff091940a03b08bc72a6dae7db49db1633ba0c33888c8e3fb2aa0369034480cff6f129c11d04b7acff3cde47705b3ee483446a96dccf7da4fc338b0b8f61d84506aa3d2938280f9d771826132fea220bc9ce935ab8b12ddeccc32e392e5bb60f47b2c3100d337aef76bb6c60967898117a
+c: 21ce57be40484c44968a70a44d1846a70b9bf7d50716f7b41f35b8fcbf669be6a3d65077a058a83ec2165856a231952525860789289e4907d3899a4cf5a9a5bf29a5ff89ec4c78a4ec11192e8f0d36b9797ac4c7c410868b0854884432c81ccc988dbc2083cae31b9dc6ae0011b65eb9cb9c826af986561aab941e567feb0562a8adc165166560dfb1e156a8e4081639ea8d626c7e4cef63dba02354ea42b79c1480e84166e23a7494653f1130e2505b24885e3edff7e7bc75b85f4ab0f5a04b50d6d759c7dbda75dddc5b9893cef91ce8fa80f138698253a5162050953f62b93963c8d6973a670989d0b4ca2de09fc64d19cd7583948a2bb60d3aa9ab54c61a
+d: 3203630eee7282fad91321a64bebcca3d3824c24a1835a5e1b7f4f1c4c7d2b0d5204399b0f5cffc4cf1493c17e42ec99b9e544333e6605b84f2ee9671b4743df195019bf7177bdb3840d9eb1668a2be4999acf1c34fdd84ae7946c9e98630650b379f89cb81edc1d92d7cfc769e75897e4edee5aaf2355117b4ae683f77c6e6b12fdeed5179aebf9b62bdd6381a8bc63374bc9fd9a1597803abb3563702845400da1548f2a75e2afcd4b5860b4c424b6b34434cc5f56fb0cbb94adcae04f257b7977f1760a8ecdea7fc59803b7a932b6d3209b852437eb45171b412c4c5bbe74883970e53b86e66350b8ade6a72c587834d9463dd9d2cce77e36430804bf9a51
+e: 0
+h: 100
+k: 20
+l: 
+m: ff6c929c1fa81e71cd100be4709c234fa88058f43a504798ff30ba2d68d5f592c2edb3c6a71e84c9d8007ce7120962c2bc407045f0981bd77b932a44df110c9196a936c6c265772177a6d3c51478
+n: ccada00e9a72acabb0ce123f33ab175d95a18c90592343636e4b4dc81b437c50a688f64d116cfa8fcab15cb851a9c904bd62dbe967c4fb46004ea919af366f4ce9620b0e164dadc18e0183bdb5b0af2fe2d5025177626600b38b4e27eacbe5963384868470994714ab54084ce33cc13a0db694ae03ff2c09da68319a3baa898af066e721355f0b077aac3a27996545ec97db8467ceec0f84adfd1e2f037c92a040bb17d8bd7ba9e3747e524a623a8042c6b5c35be08f3556e405efd67633cc35aa6448beb29756559d8efe77a0f62596100604953739290a7ab929b58ecbf180f339c81010c5cbcf9fd0a20b8f001ae548d99d5057539cb8afa2ce55dd6d3427
+u: 14030bd547d278c61d08b9bd391ee9f97863078cdcec5cba0e471fdeede51d7f82bff7e2dae505460f50fa591afa55bf8a3ac0401c2155b26dcd7d8fe02fe0578b3c406f450b74881a6d3ccecc70afc03a6504bc509e18c64f85536e096fa73c56470d34472704638f0798d49889bba2bbf024762cc1f00ab058268279c016466b59e8d34720b44532fe276fb02d8813bbfb76afacf6387a725b5570291386f3c52e1b6e55494a933b77361f63f0c0929770d27bf4a1b797b10cb77fab0207cb5c62205f59434bc639037ffeb86a354d4ddd96d22d6b7c15060679dd7cdabc503fb3af925eccd418588491b6007ee33ca5f954fb84ae38d5b93c0fd27dd10a46f
+c: 77d1fdddf4b839e5e290aaba896c08386f6e99c5b77e741d5c8c00a83e48449f8179043ee484f6b80c0216fb84d3259541aea6b1335048cf55e36b236d40edf223005756965d8b98b6cd33f22e02394b46a3276e044868bfdf66c4ba0280db5b216aeec225db976120f6955ea75409660026c0d09f750329d56e4a061daa53fc1a5e96956bd46d3b31fe93d24f320d83c1eb2ad1528f44f993ad1da9816e6e50be9e6f8bde35c5a863bb4d7398b263e9d2eff38748996a8fa363e868e5fade029e0cfd2f2d49a8be0d392885fcb9fdd89d4fbe04a2a90729bf23f15c02881bf3cee08ea40b606debdc7df324bc3a43cf1f9ab4be2afe3dc5a1c92359c8aa7d70
+d: 41491761f03386baa6b026f6ebb813faccfeb53e1d5479b2323fc573791c754765898e9c7062b1fe00d4c1ceb743fd0d2b0739688a1832f620a261b5a3fc3508e2654c140b220188747c16dfa826863b6891b585ee37316e3bddf8f638f9410abc0fe4c6373f0663d6e1afc44c78181ee10b4a94dd306bc316b11e91e235b2627013c55ce86b32310507a4fe38af713d70922e19b42bb39f43579a991e2d614562b34d195d6c5767b04d981661a6aa44caa88603c57c0811632952a5747ca06e92cf29efd59bf52de76d6400b001ad63d197d1d4a3fb69d36d2610c55a3b76b572c7575f2242e81f9de8408089518661a9aa3f2c8b01b0c5845cc4be950b9601
+e: 1
+h: 100
+k: 20
+l: 6e6d5e394529502778554f727648375842324654492d5133705d28733655293f5c684a7d7523314845716d687840272f543e52245757733c422e2b6543532638467533305d79516e6d5142614468274c7038355d516922
+m: 6843624cbbf2410524ae9fef4c24bc7332a06d
+n: a0ec3fbb0e7ec6ca2beeb92a1f08470bfcb3cd97f602eaeb96566bf2467ab05a39db4c46b38ac99644cfd849924321dd56a8cf33730c1a7b337f631882cf5dfbd5c5858a2407abadcaf8d48ddff06cc7f37e6bfd1be5097cf35e98f07f65e34ea7ca65a861b892affb1f9b4e56c663a9d157a74420dd4ef2bc86b1bb11715013c9f95836cf0dd872bffa2f2d59e7e416de8e11efb3b15932255e6a6b60d857e9bc176c8ca3d8e1dd17a86fdb4052a3d7e732c38d6e4e4c15e9e2c040388607cca6995af15c2afc362b8a0f8e5a5c3f752f2adf859d1a8c9895a0a4463e58c1820b73554e4680497af823320a568864515265481eef518fb5cf9a235c14a8ee75
+u: 197404562a196380f1ca0f46a709757da8cf0f0c8e84bc4854475f86c604d4b3f00e0d49f6b7f80debbe1fd143b87c9d47f6f00680ade1bcb0edb69e866625f1be6cae78356963a85f73a02ee92db724dc4b32eced74d4f4995fe57287d24cd68528c1d66e3f9f7e0bebfcab8e9d6d0af2a71dea70a78a99e8a7cdb00d5371f98ca0f58282dd22bac9a187e61a77893e651ca22220cbb42849f41728791ccb52dbb31c6cdc45d131a3a0e64a955a64f1a7a90ff6e782f6ce08dcaafb5315b425d9dc23a2d6f268c2e5f44d9c99eaa6c0f6b14fe7b6f431bd4ad3a4736be76dc410f7c8307098b4b24ffbf7a47a7928ae07e26769ce6144656c736ecf4d98cdd21
+c: 594d1fc4ad81e23be243b294205d3cd82730f0600b8bc4e47390590e032722eee0f758888244c0c535358a696c330aa8ad1658a893779e470df211770ddc17a1203ef2279a85854f6d3d5f61746efe4d149834535d36ce3226c464586d0138badfb38049528372850b3645d3207bff7586a3567a82d59544c5f039c1264541824ad62459259aa6c9eb78becfb54b6390d458b20d235f5898abdb20b8536e32bc354242b760e395a511634fc39f3dbfe9da48eb115d0ad5ed22568a00ce12302b5f40e0ff71a4cc52b5e8d8266587656ddccca0a9a44293fecfc3543d404af73dddaa9994434497761772875eb91900b45cd91f7df1de09326eee5efccc1f67e7
+d: 8106479b987eeac49b44d2312a8e3f9bb884835b82f48cb778945fd0bfce44aa6279d5e95795e57dca46ec151357b8c53cab67de31da893addeda5a7349cbe4ee421b9c041f94fe63362a04c654e3b96c2d131711b6c95c4f7f133f51caddd131c00eed23582386c05442a0395136a7111065f1b7cf1dba38957eaafd779cac1fbe28b4be033cf492fdfc90ba533722b5c8db15b3b6c5c9e4b7bfb70b0472778c0f4d6758681dca49012bfb48d840ebc427a706d12866e9a041844bd680278f33c73d75a78c9fc99c5d005704e0e909e064334c02024507e3b2fc74be1292ddfa4955267414c1306239105f70e5f663b1c0b7f70a626aa5cd3ab245b78464901
+e: 1
+h: 180
+k: 20
+l: 76577c34557b52797a3450206a3e36283f5671787d73785121417e512373616f647e774d76622443784d4d5e70452e275c3c217c3e3a343d552367296f236b397b4646796f4f6b576246333b6b2e244f306472747038473e58716c267c4f474c5c5d796c4e
+m: 18995ff7bbf31c9901a1629086603a55facf819a8bbe4b34a640da1c49ca1e72f7108d991dcec22a2650902319f4d36b61d6
+n: b93fc5530f86e09a0478e7024dba9496930d8f73830bb27e09ea2ca623f49580258851c3f9f04d760e179d003b79c7ebee1a06a079ff5de1821566335cee3723b77417beeb39625b63de0e6b54b663b3393d24dc251792b6705bf4533b5d526ff8c11421175dedc06ed2944e77a1ddc4e83a81e0c5d942b6bfb6b5bb85ca992e72a7bf19a294f81ff40e1ec3bddd7973e1460b815f8597158acdbe9660ac4e7afe4df6319f54143cc439990409e156d0b9ddbc40f7a20de3b5afc7549afe79d7bcbdd031443d521c3c4465b445dcc9fc0caa48075d3e414622e73fb7c626d9a4f7291276fba28b33ba0593c6986239be4cc66ad7f3da094e11dd2962ebd0f153
+u: 161c5b4cd9a95a62e16818500303630d613f0e36566f85f5bf20dff3f9b614b502f21bee2f5ce58478f9ca1a1a16dd10c0e87a124525e71249ca4dde404d56d1d0bac6fe3fb74d19dd8cc085b9fc1d81e57bdd6d01992dba83f65d844b17eafda7551ea6d94a9ad897f6236850c322a924a8981ad9f5dbd5d288df2fad4edb55368dcede2a8ae92b244686cbadac821860818937ee958365f090cd6ecf866e86896b1c95c5d36c540dca0b3cd254482b0fb0c102f724a440ae39c14799889b357ea95e0023dcc11eb728afda4263cbd7dbde6d3c01820b05e296e58a82f65c624ffaaf0cdc59fb31f7363e2d41a1a0b73bbef1b9ea2a72eb1b8e4bd7bf66aa49f
+c: 756fdd30d206d44a8b5697bf6b96e242fddc97ab7035221a61f18ba2e2a51189bb776c622f80d59bf069c168baff5cfabc148b3e644bfdaf3afe783132b8e814cd25b3ae62c1da5f9699dd5b07fadf59383e41069fe454618f95b09af00c74724e2971650d9b3ca685b083166f46885f00db0d8037eadd1f780e0af3d64b1b34d3faf55b93ff9c00c10fb8eba122cd638bb0f95bdbc7835620eef231ac828d5e1e992b1f750b340d85f75d2bf989125c3c6e5e8d9e4e9844de943b4ef55ef2fc37175092a0838882dd6daade9ff226ca19c21be68611bc66a0db8d6dca45a81a9cfe093b306da4ee21698f2390169fc00fbda7f5600628eb34e1022bb599f5b1
+d: 3d2c1e42dfc96e358c30d4e8ba12e26318a795f116434c578b2c865d17d41d6e950180da2ac641f3a5e4af55f2704e2b77ef7bab37f066bd5984f4ff1f81beab9042faca3345c32e361a5e0dd64b912390e4f49e1e7eefa7bcd3f82927edc0fadd812d4a8a1c41cddf4b47a4fe4d691423a29e334d3f52285c1f6301ea74f75170a386ab478e0ed2f75df2b6ea7db592ffe95ff788ecbf4b6700856f55daad66589270d39b894f7d9d162baea7f2a59235839ef39edcfce2553cacc326439c4261855ee79ca415f0d822bf91345cffbfad749e91da33afbc8e2c7e164e863a764093214ba588617f2703ed31735d68f85deed2fe67eed0788cfa2bba11b61159
+e: 1
+h: 180
+k: 20
+l: 4d793b7b5b6a247c567b454b6f3434797c4b20747261477a7476783a4573505a68622c543f5c772e6351676d45394a7861684f3e66515133477b3f275c726c435177452d7c6174393f4f2535555c6d37596927323e79726f222e2b35743c6a52453735797171532b46
+m: a367eb9afe1468e48625c6e893483cafe3eb0a145430a1d1f4b2b5fadc77f4
+n: 9bddea5a2c9cb81e997045355e19f126661fc6991931dc41e23dc889cf805605383eb8dce98026cbb2177105a936756c3834307a567cc6ead527d3b0b3296f987a86bbd2f41b18b16a0df4a2c114d887243e70a36b31a30bcc8f697b911cfb6af820ac6c15498fbb60165d1a4904d7472929bb2a2018331d7e4f79c479da55f6c0559441bb93deac072adc73efa7b197d0caed2a000771e10d3fc1d989c5546b676a5d2e9505144bd3b0d707e6f1eda920910b1d198566583b1705e86d04c9d697d20861eed520bda6069792e39ee1e2a6d0b6ef7cb8079273a53e235de40c96fad01b585fc75f3e745754fdc42d25260bff86afd33c9035ca050833869ebf37
+u: 1a4761f941649a718571981d6112980c08ca7be5321a98b9dc75c612b9dcdadbc71d2c05079d5e0003013baf26e8f8aa4d9c8e9439218df9a07b3ee91efbb7a6b199e83f6037e783f597b22b7ef50960477816f010c3d360b716f39e821e8f68c6f1ea34c669ad96793e512717144f367f2ebdb2a4d7420ea63dfc748182b4438907f16b62745c71166962c554b990559a807abaec599391ed3d618d8e243a7608639643e6cebd78922596213ed689380a48518795dd8572b300f9ed601016c3591afd9fb35215a5bef340355c357985ab60481031943a15b93ce076f8f04614404822833be6939d719c057e47914d03f079fca6d979a7f739a7021e3ec9db4a3
+c: 37492b6fb1773c83f67e1a50cdadef981255534fcbc6b0798a827f8035bc23155955fa1441b9c7fba9282cf3ed8bfd602665f68a42c666fb0e90894be2620bc3dfc7f94cc926ba7b5fabbba57eca26d32ab3cc65415110b175b9b96a66ad47b532f4680780157b608df96d7329683755d2522c540955796416f9aa293c55b5e6a4519a8e7bd97982ecc91681e165ac6a545fcdb23f2cfd1e22c49fb3e0712a488e040caf560bfc1d965130bf627d3a995a9838979303a2a5312d9efa7fe32eb1ca84aa43e4cddc281e1f900b950c691040d683fc51bf96e8e7749fc06e95b08eb23466317f4fc8550c793b051cbaff60abd5851a6ba13a0ca21dae3d6e241ed1
+d: 54f3744312d54893298e8133da10b6a452cde68db7510b40e0ee685186de9317c16c22440609c5054ae76671d2f2ca5bee4fe7480d07b89997032fad8581a6e71bdbe446dde9ace8d99e071eebddb233d33da2335eec9372798d252c08cb21b84eafe2fb6f988699af15ca10f57d43b87b45761751c6f2c10403bd234ea43b4c0b9d0b8c794de8821207c2cac6499fab278f16f4f926c06063c9df4aae17fe58d2a5b9f8c12e46e984bccedfa9df3491002598ff42993e973aa18e3ac4cc25376eef62d15346b0c912c3ef1a80f846ac5db1bccd81095b811c6103f1da0ec9deee490daec03f6f8807e5f16ffa1aaf92ca9b4c6b3d744982184daee989f2ff19
+e: 1
+h: e0
+k: 20
+l: 51292d7d37346664423c37633b495e4d692a6d4c75552476322c6c7e605e474b6c49232d71742c3a22577734592d355f3f603d774f233c3174364966396d78395240252f5e5d352e78276748266171433238613f506b6739773c5d75595e2722525c33305744322c666d653179223f5e71
+m: 109ec993daad7198370f1ca12f249a1b5bbef65f6d6d0e966bc143fca0694726a268cd2316ac72ae27bddba2081f71218a1dfadec82eed17b90c38224383e0f37fe03bf1
+n: d5fdfc25e4c96ed44384527ae412129b764e1efdc8e7b110a40a71412914f2c9db6a3270a0e09ca39d374d7aebf15f11920ca154e3eccf1478ff30aa14d517cf4d067c57985583e8183be956b013f9ad9dcb551302f6134bd32a9f795f634c33ff410c111158d8426a3e7e59704d8c84bf61ca6baa384edff5a7f222e3b4cde56bb2cb7e33998b98f52fdcceacd124fca16f3e999fcddc9069acac5932920ed0b615aba38884f393f25cf7afe93bf6494404d24c2e54db1178ef3be406f07bf1d33dd478a70c0ba1cb85ccb6eff4a9df409e1aba2a2fa9894348a0fd3a54ff1302f78ba12bfca56d94702238c5c6a500c223a0ad1533ea92917fe2b2c6103217
+u: 1324116de5750095387a6b9d3f7bd217f929a979d4cdb5e92ebc617bdf314a3395e60f0fd4919535eccff17188b13767e60335b8216573ed703107d70a203bfd80f2e656e5fccccefae2e6d5bae6a250a430a68bf498fafe9713a298d4b35cf18a2516a95c81d519b0ee758c0da01721c5fe9674c260eda8cb73442eeacb30ad9604a36c19c9572eee80513dcc6beae143959af9082dad9e6e036d19003404100b802c23d8800e8c004d4e34d05e519f463980b4be5c68b8d462dc66cc986ee728938b16dd2415e066dd8ac31c280924c2fe11442dceff8837d7b62e99ace70baaff5d84407e206e8c5441ddb172faa26036719a92228ac85a7f109d67f7c9a0c
+c: 01bb38809d49595b807a790745cb25e568f6381539fad35c2737fc045b2dd1f5352e151818ba0fb685708d1a5850f2866f8f094da5419efe0dad6002dc1086914d2b3f07b60a45c1b41bc7727b9a5ca52187b2d85c42f2a965fa2d47e95b0df74ecf0bde03350a742c5984f655ce34c790b8e325ca59242684f0fb8aea08b9fa119f0ae29452b089c205793e6ed4213ad1334a9a7ac3ba2f7ec9451b334d42a05c9572d82c61a78bec8014024be6f8bf9ae31a6d01d59761d7b02fcd46186c8e00134cbad2bed8a423721f2d0a66bbf2f043b5db004c4ad9fdfc4cc668246cfea70d0c50f4918dd1757144d2d7da75438d048a453767050349bd437be101c599
+d: 1209136abd64a49be3aec955b12363c1f54102fa77723c238f6718ac9b37c42b83b0e9f1e523ac3c37ca5d18b7f0931a29d7effc5f2f2d3ffe5f6903a48a03a4a0276c860d24989cd59c26fd854b085c44d93c5e571e843acc924eee48f644547785dc4810f5a9aaf2de60acbb63816b48a6b1d4adad4585c666563308eaa5012869ccad23eeeeaec8777b11ae45e62f5dfe489654f2197514c2b0facbc846150234ffb08febab15f07999f2d6d76c7062c9082f710a624918f112776b1ef6b59c6703190fab117b518df13728d2afa73c4de3a22aa20884d2afea4876cabd6679a7dbb9e3f35104e746e976d6f73675e2b24aae0d1c4a291027327c8e310901
+e: 0
+h: e0
+k: 20
+l: 
+m: 0ab4042a1ff6fb7f906b044548d00568d6fe07771e338255c4a8bd8aabe026c45317bbd3f701e15608f61a74553cfadeda4e5f2ad06a96c4df3eec9f683a2424bcefbe09749acc31b25c30b8891071809da3b393ac46673ebba9833be8788d3f893d229f30cd8f995258fffbb7c78d96de35ed7e07a4295506b6529622e87aee23e814f511ecdf88cf27
+n: d0c21f75dd112e69d031c7f4e618a302d95745e075c4a92e300bf09d28701a31016032c42fa2bdb6365f880d3fcf4e863cae6d401354c007c27b7f01f81e07b71b388c3aac1cd5d5c7cc7bc7c457ca12dd1297b7d0d5ebfc0eb30615e0eafd23b651039d20e74052502dbc51ee1b2a2cc3c63d19bfe27c05f6f659f2655ac91bd41f79a3ba274f83f966043e6e6569a717760cdd356e6eebb1fe80b86da544cfc62abd865d65acc2d1ad468e16c90875417eaeb3eaf83f9d35492676e2a638ce547b27ae91deaac10805aa7d70796c337d364327856f23123400a1d305b286ad3b4015a71c22cf178758948a1dbdd51a56e2d56e5dedf6c99558eb9c0101f6b9
+u: 139eeb457410bcae651271092bfd519fd51a00026065441880a2e42a16b84a3c922a770c7fc9f538c69838dfe4070139c3dca6a27443aedbb8e4d26162071dd3f77cf9a663e9b9df1c1cbab4c4ff668299c9127005ca3cc4c44e00937ce061c02efd92fa8f41dcd03f00521c7a67d76139063c735b51a3f078c780d4f0ec55cdfa1590e900fa2234572f4d458481cd4f34c3ef2f5969236ae470ccd8541a57de5c8077d8fef7ce522c2269a7125190898e4b1151d03d4a0a396dc78eff938aa6f3e9d718fdacaa4b5a119f99fcfa3d6d0e8e77cd5da37ecd0249dd491789cc041d48e189c6d5a12609b9ad2b6f063781ebf6a18ce0d96047c2b2dc14eab102f3f
+c: ea7e30f3967936f90c4a991090eb21768063bc44eb557c87c0011e2d944ec13f88033d93ed7479473389e5865ff0246ffa6c9d09b35908b154e76218422b901108b67195d84f62a085909b83c56019023b71420015d5d3e24f305c6a44e5103a6162a9c6defd92d6dd09d286e385e6bf7684ca21191a8db06b44f6b45bcbd82a848ca9bd76cef9d843c2a42af27cd1108edeeebc6cd34336e2112b2175ab56a0afa35fb635b43f5e3452547b795a7f3c4a111e9bae1bf51b665cc7d7220e000c5e4b26a04edb74dd394b447b30f9a6a1037442f87ea3c8523fe16986cc4406d3cd086f894d718516d4f2264698b4f0385d77c210e20eef289b48e31f9cb61c61
+d: 40b5ead036e1fa068923185cec412b9506a9657a14fe67d23039ba36d8b0f2b32c233c91d9f44ae6c14b2b9e696459e64e7ee701872ac651115371636a13fb781118cea807d91989cba91d43a28c663f50df3ede9a49a1a30ff3d5a4cccb39a3ba323be1bb937140a3782d8c362dd824555dc93e44ecd2746b2fb795c0066eb36f5ad822d5e18b54a0b3b181d66561c2e8dc6bb7977c7156786d72f70481162ba648ff3cb58783558ebb5708610409ff28bd03e02b8cc20f12033e9b4ffb829461a5ec6bd0d859a58e2e3d10861bc684f37a1932a825442a52bf880f0b94ceda38d416bd5762e99530881656f00d294f7d38438f63c43963c437f867d662d581
+e: 0
+h: 200
+k: 20
+l: 
+m: ed83154749fb945971e8ae9dc407125c6e752a8c426d
+n: ee7b986191f623382cb53c4ddc78face52de3e70fc1b13664fb8fa43ac542d7e0c0a6ec6d7891a6e6b1a7ca94f0ee3b1679faf63cef18db95e83fd9f658db0e90c01172cc382c6d8e76925480c52c223244cc12907bbe0ccc9d015c689d3525f361598437ac5084eb9f9f08b679b6f8e2e1174d9ecf4a95ea5a3c3541bdf727ec57992838c67940c33266555ca13d3497bb9e75bf85708c62abfe2f3154891ab360765f92713bd335b48067a24c68db2f9cef3a76c93320d8774de81a2562911235ab124aa486254e2007c316503793812b0a57941a3383e2623b30e87db5030ab7c49d8949eed47151091cd4184f555781dd7a87866a9ecf2fe4da323900bf7
+u: 112cdcbe200bfe90e7176116ab1e887faffbb2489144a756fe7bb9fc8aaefcd40da30bb92845d6817483ce8e0b74eed64e526305532602557a4ffafce65144d3b4360c5f77a07040d8c99d027de4bc0f71c666eaa2c6d845056e6b45f42b0a6df8d283b359a51f2a4d9c85f2213c981ed9493ceb37d23759c8335e3582622e9f2d47d29a54a2a878ccfb45749925e71d73c33c412257621c424d73cdb8119a9f1f872c5196bb5f2d8cc7dba3f4c127352672bb8e0edf017e405410ea8d2751ea71e4f041d5f58d38c7912b77b2cd76c5812c64a0a8fc35ba47e1f96bab655a89c983022fc83670ad332921ef25faee1229f6dd151052fe4ed0ebecd72365280d0
+c: 1edda52eb971457a13882ea13ed1bc0b490d7df52a4572aaa712f0a0f6f04433c211c5564bb8feb632fe7935c7de6c1a124b3870fbcd5736e733dd90696e7ef1dc28e6ea8c7c198fe661b8b4d9bf479723e117b9e8f2f4915ee47eb6850e5f5432d4ab4629423c90b4cdc06c0e5af4ccb652761f075d89c3845b0ce3b302239c8ab43a21bf3ca0bc6b6d05d0806a389428dc2c2d9009964bc353eb98d4bd064cc1a94fea87bcde95ab3809d1b5333d411ecfb43817114a016b78ba8306321b78895fb5da4079066d1edb5de034e3bed92f83c03688df64863650d9815b273258df405ebbc60c738bac097217f8dc77df6481916f5386d76b24daabbc031048d5
+d: 665466ffc4d47837c059a5a9dec2c5075eee51635a3ed3402ae05f2bb2d17f127836c8cdd4785913e38c102988b74a10a025505c6daa2e3d956b19f2034ff78fb46ac68d2db042229efb5c908e42b64b85938ac45276bf8610e9fbf26f12114a1ca493a8b04ae971e751d704f08949119829a099c3103405ca2be17bd9ab79e6d24bb1824c0c6388a4c6255d082e61ff285f0d8404646c038939169d73301c1636645b802617362372960c65cd57af7a89e2c1ab4f1b6aad8346d8e172f0fc088248b9d10864b1d6cda0d835cd4d5d2db577cf0bbbf56d45256bb1f9faa457a48992d62ff75e6192fbf6416b67cb3ec8b52f0539a6b006f7d346707e6a4d001
+e: 1
+h: 100
+k: 20
+l: 785f2331317e6d494c5925792f51282f2e334c467b70326e6a4a6457486e3d6d422c717e3d503c2b3e647d7c4331757760285e213a7e332e28496d23602156
+m: 93e20b49be965c1f1637cd0e3043e244a9045f764369f6415bd7a8ad1f782ce5f0ec2bd506eed47612b421e2a7276afd73e997cfc79cabdd09f577f628724c39ad4c4ff6254a5826dbc5cf6c59b037d88957b7886c30055b2cff26c284a19b7df8168176077940f3b83ba8ccce2ce858176fd8c005e4634bbf1a80da
+n: c71edeb58a2fe4d9e0c169f41d86e66a90a4ca80839aaceddd77233d10e218d6f30eb9222735016e478266522861ebdf3dd35efea5b0acfeeeeb13cd24dd4cfadc9169dd9d78e25907e3c05d3d51a36ff9e980f8cdbc468339e3a3c9d7e6b4ef338e0c816db96a639bd14981d2233844d7f3c891b90d6e78df2d3534611ac853196c95824daf9161f8a2b4d55364cf4606654997a6d31ebf9892f4349562bf39706a7cbcd66c20330c2bfea806ec63cccdce968d3691ce7b56ccb15df15b3bf185b37c9c00b5888b4a35c7e701d7dac7bf01dd61b23aef89b519bbe17f512776079c03b0b6a7efd0da7097734f3ca5c0340afe61e9f7f9cc590aee4cbb6930eb
+u: 149208fe5a19a734e6f6fb197b62e14fc083d63a11a63aa2e9b64631a71753d1de39d18d8079ef4142958e71741fbbcb4576c9ac4305873a9ec72e16159def8031e2125e2ab36d81ef95da94ad643a3b5658276b30acaa643281c8be786407ea6cebeddf9c7ea10b5a4a6f26661cbb4ed2000dfae41b6ccbc45d9578ad7f365d773ce6fe8d8dcdbbade1ea92696945cb7e393bd135a51c5fc48e20c5b2b8e3eb92b314f3e11f1856fdf25042ef0ed34f7adecc53d6a94d7faaa879fdc4beff7826bec6c0924203130f9b8af0d834cc21a1a36c867a6ce2ca67e86c33d24296d1c75842c86e173dbd4b1b44c86e7a79da4196e368f8d15462dc13531fbc20ce6f9
+c: 3314686f8377e04e0f2de08a65a4d84f3920ed4945151aa274a3ef89d89d8aefd575c47692c682b4209ec2ead117fb63a22c39c8e5faa552eceeb92c4e19c84dd463a49f93e01ea1e8e358a4304b7fa18db36f812cd599ca83a9e7f02571e0e0d976faf641718f0ca685c2e89ca4c2d11dc58e4451c40f101783b7a679ac536d0a360ce6b2bba650e5095eb66be525cee11745661e8b3c5058b6bf6d870cb4aaf45e1a254fc534c07a835472275a7d6020cf73beedccd0736fec31e303f8a5ed946163d1a0cadc80a4dd65c5c4d722f2c3f8962cef81937f687411bade97be2551ea4c1b9be24e164a577ad8ee9147109f34541e01f0d19b2895e71e8c348981
+d: 3f026770b59ca40663542db88ac9b84cd23bee744164e22c331c0944c961e43960876d9a5f18188442831f5d45247e478bfef8f2f220647ecab98eb17d992dc92b3463905838ae05661c8d0fc61699486cf03fdc5aee18f0770c0c4c19e0ae5a0610dbd4905f2d8f907ddb6a464f2e920d56dafd82cc7deea00ba5e873584abd55a98d97c62b43de6bcd9b5890552776e3f709619e40c5364821863ab9bf5bbbe2221aeb4f5a50352e6e01c58d7602f306d3f41771675533fa2353dd1d46b62af28a48644a79f6c17f6d8ae267808cac26cb0c9961e88e18abbe5a19a346f4bd0cda0ccb5d9b6c0c91892bcf967145c11c9b51630e83504de8e28ade5922d435
+e: 0
+h: 180
+k: 20
+l: 
+m: 6d07a9abdf35f0b8173a231401999e578b6390af62032dc5886c3b61a5294d8e9bbeb4649ddce323c3016b2603c0719c3e3703d389b037684e4cea7463c9dceb44f0d8b04dd1809123d6841c0bb28a0e2b6e604d4fec091249ea829cb1adaa93d30292b7053f8a68a8498fdee1b3da08f10c19dbc0ea2581a19a1b70b1ac6125300a45f801939aea28d4ea9189bb25a29c5d2f5e95b1ea2a9377a41cf7
+n: ade0f5cdcd072a154585c058395eeca29fb1b4b2764e3069438e9ad297e91f32cfba4d43bc07b6bf3cd7d2e7393f31829df204bdf75908a5a64124f94f238875ced7566d265ffb7ebc1f1f3b3ec5c08abbb842cbb232fc33706c851b0c22a03b8cc7182c067700fd2a639f49e3cb94170619a3105f239736f6c3d6f3fe95ca9f718444a452d2545d33e70300bd908706552f98b76016a9f2d2d59ce4b4761e69602262f38102f4e4fe3ae232340bb703d00a4560844e1e57bd43a74113326806323ab591bee98e64eaa9d1e6677bd66dc45ee622496e4324038ad5c2026e31fbd2fcb1a9b37a52a492e081ac4ab0e4c436af3d52374e2f731ba53e364f8c46d9
+u: 178e804926d45e9d85aa686f8c35d2d9036cecf0ef6723427788c2fecf369111ea8f6ea2055fc53f45e633c2db928d51e353e0d9dc9fb526fb67a51fbb660741a4286ff7a3f3edb8d7c5fa8d48e124d71e53fdf332beabada330a4d7586f006d7ad31319142409020e08fffe92395e1a5ce9f6d1b3b481a20806e950dd65a2b193e71e51582910030a20aff86e5e36ac427c49dc2dd640f2711a2236b963f7f99e58bb9be2e7f885321b6755b1326f5045dca9ad78c3fa87805332e874913167ebcc935e12673d50fd52edf3709c8785388b45166312eff964778a791cc060172d3ec2325bb9fd587d21c97e808ab60e885d2f741a3b84bde16f422b212363f51
+c: be35db72839ca6b3cd20931df9f02f8f905697287bc2678f34d45d35fbb969a7a30f2b6bb3a1ed6bb5499f4d78b6b2c0292d75462719b0688e24985ff4d121bd2a7eebbf2006761d5dee13aa602bf84c4fda4546fd7931a9d37f1d5968269f98675da5a1a4c303806fac76a48a25b39444348e8a67c9e599b3b4bc39ea50486e4fd96719a740a4a2817dc702be1c3a3a03080d946d693b46e55ade5d466a3646cf35f76c48619829cd247e7c4e16ba64e323ad8f083d0d357d269b5a989002230e7e0386234ba6da6be3b5f5725df999a0304f6c828837874e7812759b6d1b4555aefb5dd50854aea49f16f441625c8db92167f542c482d267168eb581876380
+d: 43b7b2807d7ef1239bc869dd21a693ef731918ad683fcf18e8b25e5d8cf800da4ef33ee1a9dab889a0f8a3c3cb1468cbfd4b716d4cf988dc8f01d0dae2b64c630d897826efcc47fcbd2a5a7c9183f8961b6790d6d14c23823fc1e2ec8d9a2c8b4a9f34d059579a3b68b37d297789cc86a282ce1601f12ec57f23239f02238b35d979adf734405272eb2f697b40ffa3be88ea3600bd82fc098c34333004800b499d8931c074e5ca6af9398c2bd82d9a40a51eff1e3148b0d5d4abca1b6cdcbdf466f39de85fa6ebd4e4a019e93ad56794f59bf80a1a0f7b02350d23153279f278ac6e671cde6700e8b8689d14d7e846b2bce0868c2dfc40ab53fd1ca8bd239671
+e: 0
+h: 180
+k: 20
+l: 
+m: 6e21fb1f2749afbcd9a307a3737d02a810f465755092c19f6a33f7181be29248c65b4b5035a4b702233b1488d3cc2c32e401b30cfd5472c05f4b8800c09f86ea3f4328177b1bef5cc94e861eb9612bc3a911bf4105c5539759e8027d3dc4
+n: e8bf0cbae2827a955bf0650903f857823736aa8a0728a4e05dcf02bcdce63f4ae992bd6bca76b6f8204081b28ba11b2008e8314f1516e6e5335f1af7d4d6cc4d770307af568ed88ad6274e3ae96602640c3682e7b39138f4ed6bb5a79cd9182f91ba8057d5250c8d9969d1aae410984e648cec68d3e63b7c1417e1869a2919bfeab740954cfcaba23dee81602817d262befe46bc194a958ffa1b9f90a475a7f0aa6166fa35bf24f87aff951c47fb9122ab4d188d68858338b2e238739269f5aed5c88b3883457b62283d6747194ab87e83de8b540a78630aaafa82b1682eaab1d2cb45d453df92c57ca2300be111cb6dde9441cd39090f179ff496e79b5c2cb9
+u: 11993b5d701c3f0b517fe7bcf121aaca06a92aa3ff735df55ee9a67a99c01a5fc8b686aa24d3695d11594c8c5930123add7692ae702792dde8a13403a84d75bf26a1be9bbce9293209ea804c8f22a49b3d8f9796d50efa03896595c334bd3c1d439b93947f3197a43c21c8748160fe66587b49b31136930495b55ed801fefb000ca224af7c37dd943fbc642d1a53e946d78e5fff4945177619003df729c46a04ed37aae02634f08cec9ad5e193ac83d5ea30b932f7c77502019822c0483dfabf78bdd7464d1fd1e30e5cc23f6a9939f33bf5ef2e68149bc47d18b2f74b8573eb1423f180efa9fd44d843138f0ed80475b809033f13c607944f15da2a2d4780fc1
+c: 76c7bb6b49764fc7bc4f609cb51dae4b98fe446f49b3798b49dd39ec8fccf00322e449c3beede73bf9297c977427f34a8e938ea3ecdbfa26b78830085c5c2c24263c5fe13c4e40ec6604d974920ee75405460919870dcac3ee313ad3ff45f0c84e5a1c6a66fa9e1207de220637b97bc7da457806d1d50e105731c217ec54bcfad5bb99d726191d3a11b11643e73b0f769b67777181e497ca8a28fe99e578386a73677a86e9de32a2b62aca45feba36d7dd18d31421d4048a8caf5676622a0db8dc386c3f116b0ce56c171d539e1e58b7a0a1a746a43e7f20cbf96b020c75ea5740674f14bf1c499d974c671fd623c7721aa40381366f5b2e115a5dd8281d8e24
+d: 8b29d25b03bbf93ac4f6879ed3ee715f709a101e59facfe4bd6c35a51880da096e04afb4e0c398f5a14653f2a8cb60b4e4661b6fabf2925a4e0e10907e05186dce7a00ec3f3ee4f49b18c9a662bb47c17ba1500cf89df64481bcd2e11797d8e4c61bd36022102a665513f3fda508d5a14a4ab73d9ec8afe0d14951aa151ad4e5a6b2bb0566411e860a46ac85b2f5d41e832065df6e565867622bb8b5e0e703e82b77df324cadfd7b29615870bf04195e837c61dcdb8fd748727bbfb071a9d51609555de8c652d8454ff02d9af61bc876701328fbdf2331f158f4fa56c60bdc7458e8982477305b4683b560e1f6c7b7b6ca80ad2756a22b4813d222c493cd140d
+e: 1
+h: 180
+k: 20
+l: 27392c283776683032366e73692e564b30487c42792843265d4d2a4b406d6a5a6b203c5a4d562e6d557236492d345a735f2b707a486a
+m: 2264d679dc6bcbaf7c6c84b4d6ef05aa9e262d95eaec36322678878af82a8a6b72e2ddea0e25998115e54a66677d7136af09d3c3b9d99c8624122e239240c7c488e994b1602c78f7212b275f0c4cb0178cfded473e0b8278d784b71f01e8c72b844948979512fb6b8da9a9e221fc787d7686fa3f0a414b5f
+n: b242b9cef70b20bb7c880fad99245b98799d8ade0f9b6aab7b02364177d242782d57e5ab3609534a947f42115383fa565681ec4dfe47ac5d2b5bb1c1990b2532469ebde0e36b88a198d7a8da56f60f6cca6156b8161c532c259d2442c2b725109cad1cce3c79a675312c05ac0df145ce5a8e334f0ad07955d01607da495e1a60c4f66a91617459f07bdfe110e792677abbd05bd285cf7cb8f4f5e2b65a23cbd694122a5a53439aefe900a0598b4619ef13de8d3c98c83e661e2a2618cd102a8ffda0fe98e377ced90c050e183989dbd34d8dde82f34baac6de5e7dca69e3ad59c9b2ef6801443691e2fe36ef7568536885ebe58d8c8f1f379df94806cbb594f1
+u: 16fa434f6975a3d81ad42501291bb66b45957273ec9d111f9a98149ae3098d2dd93dabe97867bcd57ea39bcd2f073eecdc97499a38af3509da4c3729ffeae6d3edbbf27efc52173d4ae8460c20078311dffc5f0a0e56aab339013e34def3c37efab0c4ca1fa7cf7c45d15bb2fea255020bf67b5b0223fd804b5d1234542e5c093d07d9e1680defd91a0f8998fac3020cff0825e08480a8412df97416cbb230ef2b440219f7b9ae48728654bd57b8bf3b9f66725f40aabe298009df52af25bc370804e7b546b84f5f47642d10c5f7a09fa56bdeac607b05c9895a21aed4e7e62de787bfb05e7345ac11b1e6fe59e7ecff14745347897ae36e8abd2abf272639603
+c: 788a31f059e8313e8c511d823b255425c3405389afd33bb3e9cf5a920e4409d9ac1632c2ebff584a9585894eb26f6e8af0aa324487bd9ef7bcf949d06b6ea83fbf28426cec0cb5b33ad031870d32be5759db9c6662bbeab787d82613483cf5cc02d805f7557ffcbe4864be26965a1d8d2abfd4b324a08b8ecefe35b52d5a922d1bfbbd4d0084ae2a679a5cac3fad610a07e2a0508d89b3a55881c284da71289124f2646ac796847cc3e33eeb066929c6a35860c444872c9b986c64be2d8288c539f0802815908f4dd03f55c9766e926e7b87b2288245936afb8e29be1c42d36a30b65ed62cde88d73b604c68f234171335b63267d2188660dc1f7f8e5699282a
+d: 99fceefe943702483d22f2d56179781f823c99cda3aee8f3595f1cc1deaafd17eec04c11d12a72b2e66f77c6a488ca1d0119c604c4521ec175c80ad61f229a757e42ead3e025c661251fe6091da15ca076d871b23c173b44d86654ce0c54124b2ec02c2c678335ba14a16942bc87c00269927fff0dd407f87c2b71cc79c2365ad4eb3157689fe662eb6abfbd8c9e850570c79afe83c31e6a63aba0fa412dd19d251044296fb6a96d308a51d9d639a8f9f297a8cb4c5176948944575bdf6fb31cb8b0a727f8cab12fafaaf3a8ca0cc1f2e9a55e3ddfeb36ea15cc442ab21c08344e25035e570ffb5604aa93775346c681f5249dc46c4e048b12c20b06ddb2f921
+e: 0
+h: 180
+k: 20
+l: 
+m: 926dbaec83bdb3ca2f439405d324aee119971efe440bd3b6408b29abfcc71a3bd641df1898d75f4db3abb06ea84bcee22aac7143a50a4c734d5328b8ae16b26cf2b12a8df3babcf59570a26c1ea4aef3c23b34dc
+n: b81e61afa514f910c14c9d6a99e5b4018afeb14402732d805678d3a27e6354cfb991dd26311dc74e69f02fc7a3427baa30914e072f510042745bd80309238f32c3311ec380b5522d605920caae0daf904c3089d93e3c99ff15419df092eceb50c4704aefb531ffb9cdcc8a311609a9402e215609bdead7765ebc7e075708935b54567c43263809e5d1a3c98d835a823aed6f97955b388d193bc5fb8fa3ff2f8fc15b3e95f0259c80d1b03cf69eb7460e074b4b3d1ec9ac8ca55edad337f917d98fb46e3894fcd47d733f06d4fcedc57a7247a2ecf34c62a9e0056936a051d1c15fe9471596814555258b01a258eff7c9dc99260659ecf115f5ca00d6f0a03c7b
+u: 163f1bfc954cc19c4dd002c4538fb397476df4045bea908d86c7801d765216ddcdeaf62669150d5c2b8e46340673c3e5a85507ede205a4cff87fd9273dff58d059e02069120ee1e54a30c3e1cc8500d4e4b56da2608cd84cd95220658710fe79f41f6115bb467c2af16e855a3ef910fba27a20d0fdf1cdea84b91c3c55c833ace5c6a12c762fb0da769a49c1b2328f8cf739e0633347ed295f9211d41c61b78c1f556ad0a912ee100840bab8ddef834a5d4351ca47027671d742df48cfede1349ec7aaabb2ca956757b7eb9a4d7f70cc07a4b95ffa8f9fe2c4bb76438932cf56831b6136f5f50234c7e331fd12376b2918eab1460d005d37bfccb018e0ef1f07c
+c: 37aa90b4bed645d1133f474a3e50206785509561870eebec5a36f198c899f320589a83e24b2ff58ce01c5d500de284a6293c219b1df507b57f731ab5f0887f9b55d056fb1967cd4906d4fc88d574813c783f6ecffd731b7cb16204e351ee477d05501e39fe586cc39263124c0144adcd63da0a769264f576d1b2a6841643924cdfb81ddb879c533ca31b18d47bdb9d33237279be05914083301d587c0dd6dd0da4b80fa2fc4ca56cdabe48e397af80d82a6cf259230e61312bbcacbf1fb4ea25f8786a941b84e30254fb66784c328e0af1399d08a6681351756bd206f003f778c76433de771beffab5fe76c3d8fc2c851f5bb981de1d82d71e7c36677a52b7cf
+d: ab5548791aa1f5c73c0eba77114dfba489da73226791dfcc53538b6f84d0f418cc33eb1ca3ddf43a72ec7e5ec737267ac049239ac6cfa0ff70cda145e09cf57ddce0cce1d709e8bcaf79a006e86a1834b66a0e8ff28f8bf56e0d31fe5a1d1aece6856f41fa2844152005c6dd34b0bb0f18c92d8af42b03672d6a55f0f99c68631bf3301d4c1ea7ddabbd7fa0161f0d60bbceaa274d6dbc0249ada9ba8d70b9ad4cbbd0f67366699e01ebdfa16659b3a0a9f9f7ce96e8ec06648f438957147f02b8612f48c78dc70d6f53e14b0e2416e67e7e92a715d3738db340eec5185ce381d353db2d2fba8e9835bdbba37996a3d763eb66c496bf9e416de62356e5a37201
+e: 1
+h: 180
+k: 20
+l: 5d4f254b4f2b50242138204e7e7c7135516276705f54762d233243415c3d245a772e3b2c77486f253428423168476f4f7a4e57505d266350494a322f743c2d6061743d347a395f54787a7d6b70443d
+m: 71452adb4d4ef8bccc71da5e1af77abe1f99776e8e4ebc1ab299ec88325e23f3b53398e6da7adafbea39410e1942e5353177be
+n: c7857403fb109643502687f6cf6ea4303e269d777e0818151ef0cf70fc4353bbea0a9ad3bc2decf385f0c6beb1e30a6845ab6d663de4b968219c9ba8c7a716b62a3063b904f9ad13c52f509950fbae715e82a5b6ea0b82cd4ec54af42ebdd1aa5c637b764dc253ec676f8f5904d6f58bc464a6372872bcf81462be5213cd88fd19d2bcc052702baef0f52f747530ef94289e31cf8afb1cdb4e9a3e93741217115abb446723a69589c4049f535d1420ac897bc21bb974cba221d9002c379669428d0e35b8aebfdb87cfeddfc5e5a91fc9af8a3a5a20bc121f33d0849f7c208cc47186e2248c80918a8d54b4bb75c15ad3ea563885b3317775bd2e8d6d07342199
+u: 1487757a8dfda8308eca5749ddcb8c4bc4f6e483a6ec8bcf9566c23df61dadba59b10497f0af5f6091140f6703ff954589cb72b956036a06d0b0ef5fa5b022d93cc08bd52e86a1a81eea36de4d0a0533f66b0acfd1fff1f40a2da472e3f5811481ea86ebb888cc32d1fb4a80696c281a6e1a913d7f4d83d42e9696faa6541c710e422e269c1ece3605a93f1c68b3d83e4b140cb550b05e41da003edfb726a09f79dbb2991bb3430201fe2996673272cb12c596ab26872dd05386a17697ce6e408435b8f2fe58b121ae2d94ac50ed85b63f01ee8e2c8f0c8cbcb2ee7849e7cfffb97db040e35655b796d36366d5b36b2d3bd0635a284ca5703e4579a2705ec4039
+c: 3ee370e3da0bc62045b697a2b08ba1f21bb7e546e77452021ea85d6250725f3c5163849295b00710402761094735ae3d723884f769dcca5e1c9d5d2851cc71afce47086659aebf9f072da1926796546d158ba25b6a87907c9590729549a0619f01e8fea25832f117a76b369df426622ffc678f125e2229d2023b87110b2d7cd03327c23fdfed24d9b2cbf03da349a1629fd326e0db44ad794c270b32067474a9cc68e08f525cf3a75b53664b275f44e4b1e31936955f7eea9c027cb0ac77c94c5fab653b07bf020bdedffbe637b8002fb0cf764946e53feafd26528073036ffcdbe9c98230f2013dd37d0d2d8c1b4db0d1d10ebba20dedb4fa42eea4e42b9f80
+d: 68b27a1194d563338d6ed781824a6b039b474072bc8b98abc1b54ae92f7812d9136a58805dbc8f0104e7f0538c7387b7e4a7c916bb4f88aaf741a0ae2092c9f0ae7c62a68ffd727ff61ab2073c840bea50775bfd809721a510b3880038f29391a9fe266f52a3ad76a5fea8d8540f1146749a301c1913fa946c4bc150b545ecf1abb7dcc3d3bf765bb0bfd31367b144967e3a79ea2231c5c10c72f9ce5e8adf8cef6ec5836d57db69b0d4d294904fd3209a36a05cb081a3acb12c597b3d3dd72224a67fa70c1c29704249f81e83e5de6bf22845597843358473e4bc8a566397d04c954eb541e99176a345506f3015b56d5864be7bce37cf32f643370b8b433fc9
+e: 0
+h: 180
+k: 20
+l: 
+m: 97525da2b8abbd75c31ef159670f3cf9f17f29a58f52d9f721685080f65753f831c4d3ca81f7ac651bd3a0e1181039e800ea3d6aad231fbf151be6fd0cf964d980fadc5ebbe9ad565e9a328d18bd922b5d14f1474785b4425bdece2e4b124be8e9f56f892dde17b95f72cd79438ed6db956cf78c04425bdb95479825339474fa4d88b4befa0606703a05ad
+n: e51f6c0b4f09dfad87b5b47c72465d6221472112e459418d6b85cbfed2d5105cec7a9e3874b60dc6c6a81fc2f88782e152a6ee817a5f852109ff89b003b364afffb38d7124de969e4e1aa7b83fc3e41e3b03fefb4715edc262c612c0cf3cedda8dd9e50d02e80e849da4f3019b35729ad40617b2de7b741de8f01689a2850cbb89465834dc16229c99badb272e13d55ccccc7965222a8599da4188a4199f5cc0a734c998403e6cc4bde20e927ca246d34d2ba602c75a4bafb0114536ac864802e18186dcf2a93322464f503b3710ce32c6313f2e87f158d0b24f413bf5b05b2bb5f9a9498f47015195bde2e0e5b785985951ed522c3c6060ca938b8756e861af
+u: 11e07b45f5387d5edf05d4ac2d3d41a4cfdb87147b9c9443e273f18252f389d66aa338f25e9736313f8c027545775c6df7e596a2557a9aff40f79c1bef86280acc7ca9e193fc1fb025eb2cc6bcbfc77da3891db3d1198f414f7c70bd57774f5b3f91ce26213b3b79564f425d019326ee45edbcd393c13032b8c30516040ee4e9bb67633e42061bb9d513b5c82a4e47f93c57f8cb849f4064eb78ca741f14b3113d666095c5a56a3cde6ea9a163750efac3eabe3f52f15c5203aa389a949425697fc84c231fe06336ff3e014e670de9ff74304670548adbdcc7244fbae4eb6f6b671f67477154ceb391013b7e031df22eb9deb0920ab1972a6a4cc106c3e57678a
+c: 8e2d3398f20b0430382dd59bb34f77e90c3af37b7955d52279ced62cb94fcb31e75fd00affd976bb612c684de6cf2853fbf8ae3c4ce6be034d5d10aeababc6dc34d4f96c45e2552db827cc47f0aec77baeb2cc775387ddaea965cbb65d1887d8b5955d617dfb3c733a13df5f9b999944d2c90edc82023b459f9f8662bcdd7b61545b190816f520abd14aa35d9ff7251afd92530e76482cd4c81914c37701454c7d79ee312b9710d9f15d11f960b9114c76fcf5f034047c5f2908ad8773639d995025400debb4cf1f60f3c27b803232723e8a7b10bbecea7cbd8d04d476aec8b136b87e887bed7bf948d140cc4f08c58a7b84de0a46d0e8603c4980ad3f91d3da
+d: 85d517675110724cdf0cfdee03dbcb2d96e7be96032593c03e80bbecb92a52a39d5df7740b96229cbbbec9170821028eaa716b6f744ee54990f64499be469d7b6e3131cf12d052c1808274daae3d7a068f64e9ff2589cd20b32d7729331e6a70e9b69547140b1917d1d27b15fb0df98093254932a6b71a5199dc781f807c0e44d1d687213baab8dbd9f3bf45218e4fc870d0942128f40f53efa05eb21f71ff97dc6c25c0b35c01fc50cac2ff218e06373811a028b9e17dc09cb779cf80e54c8195dc5b8139137d4aa9672c71778aac1bdb2cf255a45cae20cc3e527499d11f61572564e1b97377694846213bb445832f50ba460441606c2bd88886ad5cd57241
+e: 0
+h: 180
+k: 20
+l: 
+m: 18f1bed47ba4a63b67226cdacb255e08e7ce159f0d705a16b4209b116c603274857432d755897c8d2442b40ffc18616b09a92d212ea53a5537023e64c8a0915e0d3c5c951d6550d874432e93361e2e91bc
+n: b30ed3f4ac0b8e99328404d2e595f744df0a45a49d038199290532736bc7b3cfeb454dbc0895156132dbdc2864f8679a3846b05b7a5e348e9a719578224925031cf4d63bcfd50c82b6ba7fabe5336d5a665380404cf9f3987b2951f0958d02cc383b3273b1a905689f6e91f5a9cf30b358753705649a5dc854dd0408d332e031abc441e69afa026ee4580658775ae2eaa7d8bdbe88c4a5557543d097675793646053966706b05272bee3d0294302af6a78cd986285c1c00b850fe1c00888fa5dcf77b30511aa143fff42e227099a3b3301c94c42664bcea380047b8f6ac656745b332088b506dc278975e71f25df2d9f1312f14562ec26d34cc8d386dc17579f
+u: 16e01250bc2282bfc1a1de1b95b418252f8f76950d6e299a06f15339db9f5d59b8751079396765c8f9387d345bb659ec1492d39a6e511b807666dc1039c4bfa02405f990913ef50743820526f9cec2fbf1b648f4221526b45a24eff8ba543dcba8f6c1962818751de3468c4383feee8f4b041db518cc2a7f534801f5f89b65a792c22f4b54c19de1bd35a6c3c3a0d5ac97bdff6b264911e35c149473fd5220063e17cded2c5eea6fa4714bace1e21d6eb2a01b3e2337523bc0f0211ab79e6b6cfa195c3408767810c1dea8b999596c37c987e2d0f358143b895feb06382121b2dbebd062b4f113bcf838986663c4fc8f4a986ca3b48750a0ec65798ccf1ca1aec
+c: 145a8694705e01f7b6335de9f38d6eff5a448c58d492f7e4b445ba9a78477e4335c5567f3877f96a9b8077e4c0d42e1d3c8dbe26899bd57a0a178177404134d61818c120b0c301eb1c0df67eff5f7584dfa3d2088a2dc83babe77a1e9cf53831bec8e51bdfe8bf94da3cdbe4ba6a9aae30b2e44eb0e13c12007bbbaf9206005a362a861cd83792cba5c1b43c14fa05216e25702972fb2aa78cefa3e6626c7f89aa59f8e78a0a936533f2edb58d51831abf301d385a3fbea561410ca0da74d51f49b2f5b82816ba91e92b30ab2ec2818f65c76bbff11cff7436b4077bf2c973d8bf2770dca0f4b2707c26c04ca0140d45dba8480456e97114080c87087fc390f4
+d: 3a7df2a37b3fa4446ded46b2c55d733e4c797bd5c1a498d10a051d4c1ebdac577734804940e1eb0dc96af4a3170d1b5b7795248a2d3d461729a3075f849a7590934aa24e0330f98c7475df877c10c58feace0e3a650c80f8bf405d34a6c085d3ea20793897a12792d3bf5bee387722b454d6cd9f4485d19dd4b5b1229a4ada01dc22230fc52f37a0dd15a719916f2f0f787b825ad5b6fc5ea0afc45067702fce75cd3924398a8a6b9bf2015dfb48cb51d3a0ac095565e194ad7babfdc4fb72502610840c9fda980d3a0470c0ccb05c914a0db6e12fea7b1e6a6e693c6eed9efb56bc1731aae551a10893bd2c2264f0c7084caf112a9d1746a52a3fec131647a1
+e: 1
+h: e0
+k: 20
+l: 2c49323a5b75282b65266373416c5a4b7c7b7233572e52
+m: f617399a4e8a64536e0b278afe83294d92b4b8f6827db40b587ae22c09ff1bbe917de2cd29fb45403c854de560d3fdcb67a60480934dedcd98ba071474e3b3ca33aa3103ed6980ac11827a59
+n: ad18a2976830447aed747589fff4d13a0c9ee1207fec54ae8989da3cc209b312779297f5d74ceacbd33fe7023156bf92b9d708b5469f83f2671756cbd1c8c51a9ec632742b2cd63d6d96da7263bd57bee679d9c41100c94a841dd445204fad01bbc19dd907db8e058a70c5b0325e98361808b8a797edf2082a35d7d272c7f06ea803212776199bda76e1c27c377f839e54b415da536be3748fafbc373890d025dfffbd2566d11cd864bb8a20dcde1ab432310a60018184633438b7a644c05baff586348b2bb8226b608c2c6c0d086cde88f9dc326ea2b70295e2bad8d2c359450de136983d096e5c80676d9ca021d3aee8fb47f4e5b5890b0f6694c3b8752249
+u: 17a9c369717c37eea7b3baacde0db1f5448830c1bd92acff33cd33f8f17bb83305a388e90e48641fc15398db7ae09fedfbf175c18a7703ca82e8d01a118d51a952ea8dd5aafef7c1c105990a6fdd3ffe1077278d691fd65bfbb6f306fc8ed2f9a48cb7a8af514fd61b38c650d76ede26d23b76a56a2bdd6febb0a5911b59bee24c4a1002b9c555ed73a8cc78c3c90cf380ab1e3c358a99f5de154ae14cba41048af178f7e662d9482fdd93a0f49b58243210dfc259f4c437b93bbf57b14aa51dbd13fe2b28531ea85506a0d5b3d8924df7e09b98ad5ad4c70ca48a3c807bbb5db8bdeebfc286ce21b37592e00b03ff8c259669dc24204dc7abacd84867698c9b8
+c: b2c084a4561c4fcdd9f5c47cff99cc03878d51c2ec21c51c22372b6d9ba003c36b2226a29980d436d6fcbaab740f1ce815533bed16df3b5145844ff5b9b0db0074f0831d6c0271f1d5d22ff096fe549ccf8b8093ca727c61904d35f99427d6d89240fb42cbacfb2242305a28052fd62f7cd12025aca873f36e2d3ce7be4272ef66da36f3398759ad87fc15741b2219e3162fe5b5693ce3ad07858e5411df37a5f5e90b99c29e8ccb0ec3f414be7fe46bc077244fb21d2a235926df3c8864c1d8b35b2c4dec000690cfc73131854a17af92ccda88bd859cd524e1b5e0eeba2160b1c3bfbfa71f91cc18bea12802bfdd4dc40b9728d978d521afd0a45bf14df552
+d: 3e6cb12d56d0967148906d61a78e3250ae22d9e6933f97c4eaacc2f5ee0126221abc8cae0684763c49ab0cb72f9b799f21b3018ba3436a1e80c15b660c4a94a61a4df1875251e1c9296047c96e39cc782cad08f6fbea414793297b05dc77060dfefc74648f84e44dd3f6dd062ce24997f36ab25a80a023138c2994398ce94301d29b1fc07443c40f75f4e94a93d1c3d9127514096815b016b681401b1f0c3889abf73f105fe51f686b20889035af29f994130cab720db856b78054c62f18b5028740e70edb8c051027adbb7927c7685157e6589428417246822fedc0c45632699abcdeefe9787f475fa0459cdf26adce3974827dccce60b63f01a8b00a3d8e5
+e: 1
+h: e0
+k: 20
+l: 5e3079423f35776a73756c2b505133402e3073596b595e294826392540335140287d547a687b4a7a5b6a3c656d7d656779562b4f476f
+m: ca3af3aa68af16dacee36c74e65cdae5d70e10af2444881dd1b8cdfb905026d4d4817ecca1dad509b653f71a5b05c3a98a24bf94cfcc1e805715a5ec7b0f2cfd9d27b1dd7a1e0f356191a7f00a4ee992e6b85abb57
+n: c65def3e431a2e7f180d61577264d08511eb0c3b58da3417117f796153e608c768a5ba3909f6078e65c6aecc841aba3923c671fb4b0f756604c3c67f33a50d1dc70d0e5d6435df5e13fa414333e028574cec9b5b9de7bc4c847b4f6ee9ea9503d606988a46d1f8af7836a0d506a8b1e09561fbb1fc5bcd012ea2dc177306c064894f064f69e512bdfc747b85278b6886af442680f1c682f3b7cdce95d7b4f036fabfcd325b853f276081ff0d100dc614291f1d929c6b47c884d2b93fa262f67806f3c8cd6edbedf18767d9a084e148e3814fcfa131c1de2bd31e9480e87f92f30b98eb1d37e04e9cddcde1d16977ea23e3d92ef717173c276ee6ec89eacb1249
+u: 14a60ad6a86f7801858558e3a266e8e38f681c67d9f1cd8cb2d813a7b1aa14fcb362d2c069d7c8d622fc3aff00d837f889ec23c72700bf492f01b3d93b3136633fa94da2489ed681a10fe00ee14215d44910b7762e95fd8c5da094085948105c5e88daf783ccaebdd6afefb584c55937c3b7ec64570f5a4b41470133f4b32fd580dfd4cae8772a76b576ec04c436fde61e12cf0c6f34b1c2d7d180a5dd31f5eec8cee85a85a5033c7c639860f9346313e8f2ece550c506c59c39a5f2ac5bffd6e2e74c4291e7c7567e2b841f927a953197f9576f1f1f080c11e8b9cd4c362fc1fab08e89f22e9fcba320e02463eaddb5f314cab5f171d02034e7570a1d4ec78de
+c: 8f92e8abbb384b1e0528b2660842f0f10d8b951757aa0ce7b340e8f56bbc7823f7063cf3125a826b896590609688d172410b82bf4d9f9eae974ce7d405dfc26bd7d554166b36a97634aeaa19f06a61d9894dcf4daeaeef75e88d267c658a0c27e7a8774dfc696a13818eb24d680d6041f32800bcaf0a905ba2bd84c52adbb79f2848ab5cf4485be17d772614fd1854b047a87fa1995a54892c0aea3de0d74350be23d3742152b613e5fc9c6a6d99bf61e3bceb6617dec649171b5a2f32b022dda1594ec21bebd06ff5d71070a3a6890bd27cc752a218b92292079517fb97b5f1aa853d7e8e32260812d7ebc877d991cd85a82b94fc17bed1c376aa6d0d340190
+d: 6ecf0d807c49db4847e20bde8933fc417a4b53044723c22b22e1989d9d3b20010d1edb6199c4b6058e534adb053b8c5782dbed6a2dfb0626746b6b5f7a02cab61b885e021d1f3ec9d336b2b25e9227185d4ec252f932724af74b99fefc6887cb5155e2e29d1e728b3f32fb73a8c32a405f4f1669c89a802d0a12ae32c20b8b46af418f13beeb479b0feb149795eaa1e29e2cecaf2d859ddd0fab504ad82a8399525147e62f0e062140fc95fc586617d2e2819dcb28ee03204e7c93b1a43007a36b1f7884607dba1496c69852426f051c164bae0eb02abdd4208c06ab0fd009f7e79c2f37436b2e4c2218ec147b39006e8927bbdebbe5c394bca813eb94611401
+e: 1
+h: 100
+k: 20
+l: 4a58776b283e2e5861725a493a26393b3048397a704d2d40247d754e52637e3d76613838522267582d5421203a72336a25325b6f2542532b644c625c4f2f48404653453a3f5440772a3d7a6946526a6d2c5d49377d453437374154326d5174325c522a4d57675476
+m: 67d1eb1591017c3a0932ab3347c56cabfdcf6e9e8e
+n: c974ab01179815f1eecd596d925e593c44b89fa4602f55aa96c244da1720d17fec3a76db38be8cbe0395d31b0b2e991389bd4da66e06f5e5d3d00c59593675e4c62744d17e056cce04c6a923ea37433a5250e638197da37d65db14a43c467a671fb5d4fefa366cb21093ad199888f0e9aefb0a8441064fd1b6986e7bbda1548f8bd3f8bd32df299fe5d8d2fcb45182191777edc11ce03d77d7d972a7dbf2976701d9acfb7703dc575cc81629c7c32b4068ca9fa173922b933c97d337d54c9ec04229119b9648b9710df67ff56b0b5844652e0e4faf9aad04be1192679a5558c998c5a2f04b5edb25fdbdd91d7ef7ac0eee06deaa5329d0a147bbe4959764f473
+u: 1454fe9b177f6c1a219c586eb935db284b3b359974dcee1e6ac377054cdea2cba178af6309531530a1c3f59f0173896423eb2a51a3d371207495d98ddcab0ac083209a9278fb62aabafec86410ec070a74189323a390ef0779a4870c3f8f28906269b9c443292063a96bf8e942776b633738de0f8a196340e51b1e1a510540855e7a5535a03dca782c4c14ab5bb3e763a90ab8893ae376f19bff348d7f3065c72e364f044d136162a0bbbb0cf57e27a3bf4ded870e73c217a31e03d70e0afdba28d509eb91a1dff2b8c9e2adb60c7dacd728463022880c1e717b4d7ae46b9ea0464167f934c8fc741fcc8b8dda6eab8de34eed902bff1850921e1a7a626a8dc61
+c: 7c60c467fcb906d89e5d8ff2f36f06a45e3bf41ef14e612dbbdfb9de260a640298d96fef3be66379cd898213afc7e0852dce16345fea3b08ed85165c450977e3315fe1874d736b9d29e08b789fa987438e2ab356bb749d4ba8c160c4b24cf86bfa2ee18aea6856486375abd20f2d6d3d5fb671b6539b3955099f082048256923a48ebd70d90d54497b53383ed1896b7a8c1e465b87295b8829baef8231529f978e33fab810d152e079f6bd8a5e17e11c7521573f754d4d0b3742f7545a14669ab0bf7676e0e653ea3b2f37d1cbac30b21125c25ba065aa2beb2ea260b0078cd83ff451eae836aa60e273b95a718d66838078fc930136c84972577cc680463f9a
+d: 87173ce1ca2313c4898699df80db08fd7663ead607bae4953dc03a6652bbb173c56cb2cccd0bd11cc6ee379cf00fd800247119b1c0aab6836f77aab1dc9a42317402ceb6f423c84f42ece574490632a2661599146487fa89730099c1294e71c2fe6772e87ee1f465301cd573c738b3bfff045f4cb17ded2c4079d888fed2eb7201843f19cacc58c41ef99a38d2b6f69aa0f504dfca8b66d727145501096ced894e525507eea05809b61812883e2bf30c154b334e28d7e22c1d466f24c969b64391d7667c11625614382fc7a2b406fa0bb44b10ea8ba14adf1536de8b76da73a9e09b603767a76702d495089550be8996c86daad208de2a7c3f21697c8eebc241
+e: 1
+h: e0
+k: 20
+l: 2f3249485c345d23653f5c67422c4c46273f3a4e74385236756e2155262c5b2d31363d3f32674c5a794b7070695a3558583c282559535639613a3740694d487974555e7e625c584b2036715c
+m: 
+n: b89db0ea10b95500fd383298a5282cb73462d3eaa929a3cc825e09fc44f01d4b1798f3bae6b339f9ef9df08eadaad84e0c17a62985ccbfa75fe9974b231ad58c838e80a3a9f65f4afcc154cc77a1da6c0caf0103a37ad69ab5c4529a3a1ed99803216c9f37826082b42fc659b5085277f9b3ee94eb5da01828b040961b86006ad3601d2ba6369b5a3797d979a554eba19988554593a5cef04a158e19a340d0e64e078a51e9b9d731a71bb359b1b8655c5499c657d70030059f992e48ab0c7ea7d7ae371e4f588757280e9b6ea43220657881c98b24b53a5d3ebdb34d493e3a121a5277098ac2ea0d4d9868ec3d2121fbaa01f22b1c6e88f16b6735011aaf580f
+u: 162fc4b109dc62dcc8de75e044fb8bb5b871ae8eb53d7bdf25d4812abc0705cc07776bb804e09c7667f8df5b275e8f56cbfe469821b369a0241c77345d6612b3a8bf142ef732979935d530acc6d62f6872b4c09cd86675e9bbebe700e389f9b2668f4c8c6be43d0ed161e504af0268b4d93c59a7ad893b1318ac2daf6c1855a345f46927ee4e48ccd5f2fa662e436c02140eee55a04ba59304a6303085a5e671cbc6bb072b30a2e6440ce18c1f94a89c5c5bdeaa36ede443c9b1d5502fef03450a9b006d02ccb5ad5cb63014f5b4fd9a18ec2e87dbb550fe948377c920cc0fcded7066352ce09c8bcc9c05b0eb204be6c59e599b5591092d16ca5a2ca25aae77a
+c: 1291e834ec3c1d0a6546f2fc43ca8648478817795edfe1c6893ea5f48415ca611c2d5b42eb39d6fef7a963a2d6faf59b59969654761e097e14a7a78617010d64847052493192bd13f770174e56cad85750621901bfc3b6c79ad650122f723e3747cff7e45f821e9eda3883ea79609693b1a7b06c16a225e8f14d69f713c7dd8716e3fd33c4a6d0ee5e8f8549e4dc1a191575c0d52e80ff7fc4658fb912544aa175fd45482ce43a632c0dd4caf34547cb0f0832e3d63dad0c6e61a21cb9d12e538395710d36da0e1cb8e4101a8571f74408446fec62eaf60c738c07ef3780f6775adddeab2369f88bad6411b174638a613e6320c67eedc1ee64f2783d9dbe39b8
+d: bdba2306e4f2717f00d5cd085dd1145cb94a966e64dde82563798f6b97328b0e0bbb26803cb6f3db2fbd95704d9f9b6f4231439e4f4c8a0d322253ac1a40d477354528309486a3a98b3343d57436ec05d7033fb91bd467ca0d2944f4cfa3d7aac5e1927710ef5e4eeed9b30d6fe5ce95c6d3807f9f0382dd91b7a64ac1b081ae6d332a975cf37aa82108ca64b13c01104a70f0aa2a966d1ef45f99d3fd9ed0e09f4aaeabf3fa1d2edb36c24ed401e34121ad2e48bac070502394200b3c38b4dccb2c8d9c03126403970c99fcc28f0e8cd871d5a91033bd45186fd48a51bf0d8500a4f517ea8fc74e82ac5c2636679c4333b44c0eed94d3979ba743e9ad61351
+e: 1
+h: e0
+k: 20
+l: 5b4c3057386121794c3a447a6579744631676e6c232b7622743f5e505d504a37507257214f5e512977313b22503d2729596c427248465f587c3c5c3f5e465e3e37285d7a593123614941767b452f45673d7b7d4a2961673c58366c5b515939307e7d5c2e5f6e50597160416f33
+m: 978bedec7f57863175ab2666cc505c69cc2eca298233ebf82353528230398a132cdb488e4b56d2a6c43e3b5f89cbf36adb1fc9d8d9d4e29be236fbf6cec0d25bb777d6a93aa677f918043aed9663746e63a01b4003a53f46f2542f97c8810b0095667483f6c728720ddfbb3bfa082ccaf9d7e60e01c1d23b4308f8312fb699feb3edbd9f639c533421b82f5948c98617b19c30aaa8ebad4cfd02312855c16a69a3c9a9c0d212ebb8c597108254939842396dd77833cc1d737009d24ac6ec35cc1552f8eb43f4
+n: b99b3dd170c7e587fce66f45509eea58f3bd0c81d8cb48d50fd4e7fdb3b0285b10d95df501bd4bf2321bc730fc7414d84f5d24126a2eee6dac6ae5d34c2bb61c48ddef353de7258aaa34c2f3ecb9fe65dfa131f054abf1afdcbbe5750aea9134c17fd161c749000dfd965ac2ee4804dfdc34dab72daf4cdbf1a6d3313fdff985854ed6afda8107741504cdb60415d09138117b8f62cdc3c759fa5fec7f521dd195d5c11a9b06968bbda5653750ea413d86b291ff8f6585a7b73db17ce4b9673a89340d190881b444ecaef58c5d810e8dcd000fd2f4c2fc7678f8f70fc861c334fa3b211974956d9739eea9c7da203bb346022e35012d780b91a97c8e0f4bf97f
+u: 161175c266c25a4afe98a3f07338942f7f4e79a33e7f29497e18552773d400fc21c7ae74c45daf5e1949da9bbe142a300fad81cd1d8fe031bea36117ed65f59e58b530deab15d25eb9d0ad4f7edcb41891dcbbdbbe0ec474a4ac9f3f250c3c439e326cfbfebbb24fee50ced3ee0a6e023bc2b4ca82815df87f2319bff8ebb3569751700c7eae977f70a17c5ab06c58808eaf2dfe11c8818650b0c8d336793791d128c12e0cbfe7b3ace626f732030dce8ba7479fe3c08955ee4ef07ef3b4ea200913ff5350514c86d18541231fc33cadafbab05e67715b3a85ecd53cf647ee7c57ac7bea9e6677881babe27084f6aad83e61240be9bbeb740c94351ba33a539c1
+c: 701832b097de7947a976f107dbaca00304a3993a70a7c56f2253e93b8a005c15921f33b5f8f2f617cd749a0147fdec858a21c50163fed15715d34f0466b42290460d8e3ae7aeb5ab6be9c4f04023601d63668c2bbc44aff84ca91e3138945d15a93ef5fbfbb7ba1d7652f3bbfa0f70d4a2c23a143b330f1af691d6ecc13e3ed4dfe15dbdebd229ad42b8ec38c04fa6ab05f369e05cb82bc2554f891f5c6538bb123053f69739ccfda70b375fc049e4b2bd46d1ecbe7ff299aff84e0d7d727f8d9f2c810fbd4c560e591a4389da18491ab22deeabd99731fa208d766294ca6f6ff38f486ccd181be1a62e86c69fe78eca271ad9bfd5e083a000e73fa2648311c3
+d: 23ca05887f16e3e89afddffe487b0cd5b3487c84c39a13f9a0368cc942769e63b0a9f09997221f7dbb0986255a662d97f1ce3ffa68ad37d3b1b05cc2bacd54fbefafc048586cd14208b08a0df0188bdbcf97c762e816b5a616f14d80805ed4f4a8e32811cfd04d6b3604d458e6f425885f46ed4dd932778cfb5d81ca8943f38b5447c7e951bb59f6517c8d048b96af3da35489a0972fdeb9f979065a965d4bf1cbdf591576a92cde6f68c652b4a79183c3a70227f1a309f46526f0d3128a9d6224960f0f63a37ab5eb78810da4ac1646072d810fb0f067934fb1522db705a2c9e8503677f1b81f06801502a9fd32f6f9184220a538871b87743633917c6d8fe9
+e: 1
+h: e0
+k: 20
+l: 604f6c58243e6e4b67766b582c484e2d7d4234214b495c4249717a5f2c56272d255d5c512453444c65584864413b2f605371744c503b51642b3a252f334530236a785c643d5125724f3d5c72453c6375215d612f5871352c69416d427e5046793e4048313a2a55206e512267533b697227597d56274e4c
+m: a2711ad4068079f3e7108b48a6e271e2f7ca5e0d98f08e3b37a3c45d185ec101c958d3a703e056492beacbd966f2efad9cfb0c20b4aede8b2a6e3006934ec2aa1352d81edbabc17c60e70982353d3b2aff0554d349a285906f36903cd2381ad2fa1b063e4f5e7f7b943b5516c7
+n: 9ce1499e72327e988b257f8c888631fa0254f57db2f674998f073104cc71179e0ae23610ac3f9aa1b702be24f5bc4c0f897b0e7214fc65501bbd55111051a30bc65362f402593cd122718057914b267b089b0b777d59159af3d98418f66ac3d6eff3f64a7b37581f274c0c388fa46fc9041d52e75e8149d7207d6cfc7080fb3772a8b3b54a3b058fc18d8a8fc32217734f1197a84af3b038d2f8e4c5d8ac68d3225f48c79246cf950e45064b5832c547d5cf250e28f60d16f611edd745b5b077dd4055bf3c48436fc25de90e3594a86f4b0ae339015f304dcb959a841b76c4ff98b0e7f62c283e56055d18ecec6b0307be204e75b211ad2b25ce62837461915f
+u: 1a1bef7d59ae01d2ea13df7395457e7649d769718a49e05371aea9604e4157060bfe78a29abafeb860311babc26558c6de99031354de3a607a6b3cd7432a888103c3c1ce8301e127e9cb647ef040f9feb19a013d5f923b117088d47ae23971213a70a4b44fcc40e542ef2b62660c3691ab6bb3b330001c2c83fa54e809a4dc69d4273f91707623f268b51c9b3d2bbfbe4323826accd5854525bc793c2f3315d0c067b5e0d4e0644f2f879f97757ebfe0109c01e3a1124b9c54bbcca68405909bc719dc32c237906dae4f61643905beb1e98e03c202400385aa7fc7a8ee03b920e58e21d8679073973a0cb658206fce4a9c35263512340dbca42345424ec4f94a4
+c: 84789c3b28548fd856582a4ac218a574ac3867a66025cc6b1a6e1127fa34c476dfd609f963c4b09dddf7052718d95b2968dd163fae1897d4f9a961150a46f22cbfa8f87e31cf8227af3919c593c2923af49b572aea7084b7b58217655bd9d65f65631f83cb63d18a8f5995d2279da6b843e9dcefef3e29bf535673698bba88b744a291fdadb1f0ae75b00961a11ba115716b180ab56d03ac75ba866eea69e3652299cdc36c837549d22f86ef3d565ae918e6231159ba66c4e5ca0840f20a470a2ec15c4d5d6623b42575edfb9aebb1cf80ec6d55f27ac49d2e4c729c2099facd5da4f8af8637d38baba9e7c4c0b1397bb2614ecd00f71ebda1812b3f062a397a
+d: 21e7cb030ecab1db2e0d97f4bed0f70d859864e59577abee0798637e1b87c958368a9c6394cc0ed497fa7828fc01cc88e14221f842d57fa1d2c27bce948e9e52e4fb428da23c9732081ba2c612534a775ee83000362d09d240faea66b4c97559d3dbff1d538cc2767970680e02009c9ff0e48146536dea052441419ded27acdbc6f98dcf8583f9bec60a53c60d5df8ce06f020f0fefb282805c079b689c954e690c96b42f109f4904e5c641e0585da1d8d162b43ea4fde451dbed4fd62ec786c97e408bb3723787fec6f28a7337787038beaa9615b929cbaa984a9c6636ff5008869c27ebe8ce94e79096c9f3732543b3f9e4a0ad033c3d47d350c2a8296d2e1
+e: 1
+h: 100
+k: 20
+l: 616b5562595a7671244d7224503c4824487d615f34436c272b7b3c3b252828524c48322e43604c6c45232e793c46446c7b3d7c7d43754c712d70375b4d26484f5b2d46605828217d78504026295749645650396f715e6c5d3638543e52425441293b2d635f544a2a78787e792b7854752c48395f79213e2e243934
+m: d94bb12ef259e449a2800fcd881499a3b09aab12e723ef46ba2e6a7c62f31eeedb780af11dd198924a56a044b55d0bb15848bef345383787bea60aadd4d3f01d6177bfbb6d27b461df116e925ff33a0e5af2891ebb4a2ac5d6d45250607ff99c59adca0d0e0e98c1c4f87a1b258e86d22df2a799691fca77269c97883c15a201258c3aa06c699bbb9da08f0ba7236606ccca01ca28cba8c95cb713f94b629c0a0402fef74b56d81c4835a559abf205
+n: d5c3317f3e7921f53606cc1e68b5343273d82a4f1c92e942ffbd4979a8b7f00aa2db02191987904e94ad15633a2a0702c71c86212b049148af4140608c352ad09352e88d61358cdbc1961fe8e0a2437eb10f11d0b85747607c0d2f594d8e208a23a7e863f421bd57016ce9eb69bd6c65e5440c94919a20d457bb62a941de36390a45295379c28669b0ccf84ddb0309117ee48aef0dd0c97898c8b477560a2c622a96d95f2577efd85330a0e4ca6f992a8d610ff9295ad9ed4c6c681a0e00582530976cdd39701d78337e5c746e58e2878870b118d88bd90ab0ab0bf20d1b8fa8d0ab2f4a50ba5f570e8562b9bee9826245dfe45dad66867134342b637a277acd
+u: 1329551b53c97e7a970afb0e93bb16fab065a84cf8ce4f8c10f31c93d007ee2e9e9a48c4ec86cde42ae2c7456018b68f4fa568870d5b9440b921bb72e66ea89e7b43b5aa9b97655024be1ea89283c1d399c09f20e090a20631240e8f283c03c85fd5a4e997e5f4082eb0598e583cecece12057e1897a3e47ff62a85a43fd77782dba47dbe246fca4c033678af37bfbedf4557da1de4c12019d7845f433236ce03276a44b6a9778a06b6ae5a2236e7f099ab27c7f89a73f505f924885b10fa422e9e81024d217f9d8da07530656ddab1e3927221b650cd482e7a7bd9135f6c6ae7f71ac39be6595463aa04332f96dc7d5c6f327893da2a62f8a73c2c00e73c20d5
+c: 7757aa4f29ca992fe1e618822d6e38b61589bb90568b1ccb86c12ac3680b7708257660b5501c592ffc164ad3abbf2e948d8862e52611c576214dfde2b8e7dd200eec38c732147bc1f6cee875a4b4354243dd3e0edccbbc9a97976e3427a95563a815308aaa1c678c34554615bff7020456aa2c8feaa98356a069a50606c5cc85c5a6dc22e0e64a6e2c06ced49b79da8d9cdd95204b74f38886bed258da5f9068308b8d9e1f287ad506de25e558d1e2553ce0d70fe4ee75aa47c7a5c5dec68f7e38ef28c3aa39f8ae964495bc4e85fff71cc0cb844e1ef6f59019c832b9f26d1c8d6fc1776e4c2ab41d8282e21d9055d8185f423a82c577d1342ac009e3cad4ba
+d: 9af18aace7ba893b87fdd6e664b45721b1df11927a6bf68077e7ba9cb9b4b69c9993274854bb3c9e690d279ae1a3c04ee7e0be3962774bf9429db538d4cefe9010f0f71adef18a7f83cb8adde5f161bf7475c3df38855f4cf615eb8f4a7f822e17f7d3b6c799cfb6fdce90ee523415bbff1e2289591d5a9715d5151d6a988907a006bee1c3836f76b3268c44e5146c4514d92ee7453a59997e5fe38f23bb838a5c1235458cd8047e1f9507a4923c557d1025f35242341c1faaf8912cf0719a9b0e1fc0aecb02cb5a9615fb941cb9c6bed41f0e91a38853ae38fe2f8bb47470989c269c5c4a686c14f84e1a718c2d0a7d0520abdd702e7fcc62fd76832f9bb181
+e: 1
+h: e0
+k: 20
+l: 3e4e69512454316b6e3652497d243a2626382c7665487364613c2e6c3357382274206635226a352773344271416c7b764d52555b5f4c39697d26364d375a3f7d6c6a7669645d77734b566b6c2537465c7223696b773b544f53455a5539473833413b4136664c457765626b57734d233764
+m: 9f2d5ab42b9a61b98dccacfddad57bf4c4468090501bbc60a79a1443369f3bd1255a7a166fbb64a15bd2
+n: c29a25085de0e40f8751b1b6108bf01d52bbcf0bb3665e4418e7611b503214fe8b38a4dbd40038f4f97f56a521dc026335c5dfcc322e91e5b9f272e6b32d1401c889aea5dcbf5c574c7ea08a8ca6c86a0a10338491245b84a67c0aa463fa7827e2f23f363e064940224063d4e6c53b10510ebda753c5fd70f3f26033055f3076d5c3a4767f33234d162ce1b266fb65b25d2886d51aff9d0505d20d14ffa5e067398b7a4b82990ef8943223b51e15ab8b17f6fbe87d41b104933ff854ed96830129171f3bb737259bf283b8ca4b24bc68fb25081918bc3e49ab7fa3d2e1b6859fec7398099913c0691928eae48fc9d4f1137e02af0f7d51af86ef29d6f74e26c5
+u: 150c4e9574f4f2cff190e2ffb791b9101c33489958fe29a12e75cf5421844dee37373276734500babd519eaf9697b5cfd8195b519e1ac8d7947ae8840d5c907d518a319b400c91b34cc64d7e27c8d0e47f3bb8ba800361974e9d70c7e436f0860801a3d9f61ffe514e9c2c66ba3b1a319676026bbd2a7867a00103b5825ed8f131055ad76051cc585d2ae4d31e0c3db19cfaa717a1ee24254e7274530ecf5c70d3258f4102e8dc23d2b8a1f88caab1053d4f7a9f875ae2c44e1c1b4530151f669f8e24723ff4c8cde2b079a1131344870941a6eeb91dc7d8a5b598c7091e86c529b70b09e7416779b58f277c0d30af5af1e5aca215c88bb52f154ab47abaf0090
+c: 39c428517ca5cf38f8372b830d500383f899943e02b98dd256b3b842a00649efe1c9fa1421cc6f6e8cc9768652824c600adfe2d5e8c9a8d12e036ebb52ff478f3378b0036f4ba71263bd1ae7b5d7b1da07bfe67b871e4fd38f2a0ab5951ba7e6644a72e75d8efb3e2ddff5914bc6ebb48502f49a36e2cb02bf8066633fa12801fe2f3d6b8758edba137f4bb1b394df5b9c59d05d833354fd6c21153a104f0d031b21de555d3cd4d4c2a3f09a6cc658dd676080b845d427a74e2cbbca77791d0ce6f586dcc110450bf1f54d3a313fe0f9b198147a283b3709154fd676d3c51799e30b4c37a5d57f99158c9cd61c6a7cccce718b6dd44088ac672ba7bfab685e84
+d: 9a1ab5315348be278381bf866e78176a3540866fa9c89127864f4ca8602cbd02b7b08ecd3052dc0fdaf4108b9c70f86da5e81ea9a779415adcda2c01de84b1e9d3a7df37180a6dd7e13375abf3ef9ba214d6761b28c656252cc52e1942b13e64fed946b0938392a0c7f21280da1747fc6962cc1e9aa788dcdb5fd627bc39b57379580f4be0c9558d8a8add76723dcba30a06de50135992bbc4bfa25778459db984bf7fae001ab30eb28d3a3dc9b890a5b33277aba8c0468ba72e95162b6c3f88eeefbcf7b64eea55de87de7c6488823b5403e5e010c84c774e0c00868791f3bdac19374384809aab8f56fe6e81744fd49116d74c1fcb8838f022ff0b4ec4f8a1
+e: 0
+h: e0
+k: 20
+l: 
+m: 5ebf90aaa6d32f1ffd39c73632dc5622ea5d8112cca4fe9a5c4aecefc6b36221631aed89cab94c6f2d419c47a2b576c3199da991f119c8e873ed32740edf1c9519764d
+n: 9ec3455abbaf2a8dbdd47836b8d63e62ad857ffb0b00d740271c76aa99aad1a98fbc6b19d72133a88e81d64a8891ec6fbd40a3e01eca11eec0b7edc31d69619d6543fb43674f261e8008975fe7a4b212a05024a4bbaa74ab7218fa6665910c12e30add19d62e2cd0d25e421f5c091e8b00fc9e1c788709588f1f39f8d06e4dd300b7733438556939f8bfbf61378ac571d19ee83d868bda9ce07c91f7399f7a299866e3cee822b46de467ac8fdc89a5e036d48dffacf5ae2b00d73add77f1cce6af18ed6a83d7875100bd6d1de6fec544ad1aa0ca33707c41dabb7210ce3d6859b74d7ccfa2fb950572af931a9ca50039d482cdae6f2af29eeed162822e953cd7
+u: 19ccabec204ac9c58c9a07fa617a9f9c02bf902fd4879533ac970d44dcd3ee76da4686a267e0f51ddb5fee594bd02eec90ed75324ed63b6223e115e8fbc2fd99ab0a4ae1677321f094732f883cfb3fb060ad5de79e838a306a88a39db4247220f90543a6eb7b3be6496ce50825e5ecd7884456cd811404433e60a245b778f9998b9f8478815c059cc57c4b6d37ed151dd5bccdfed40b6645e113173b214af030367f99ade46fcecd0f5a1a86d04fb0e3614fd88108cf2d1a8d7c3b2961af81e290dd7c8eee2e9908a91795372bb1ff27fa1d216058d2b28e0ff4218d8810bac3e46bf1907ee303ba211afeb245df03bd8f7dd4b92e74e4dd5aa547f926b82e458
+c: 85fd966f22c2744888a69a923f62873f1ff8ee15e88d6a720ec9d97fef48abfc330753b4f4354a6f509b3ab7673e81a6454df89e765fbb9570a0e38b46a16c47ad8d99b40672329cc8c8aabb629ff23e9890f3da28d14c70e624cd77e7ca778d355765fc4934aeef8c030f96464805166101499669e8dea88502f82ea37f07b39ee91483eba48d6c3593cfaf6657bdce8648abf4827802f604916773f0e119820b606995b5cae820a1287843ab4b401362a000515c1a96b07a84806a0e318c8de7fc1ead8233fd31fc724bbaa13a770cf4a71b28bbca5f27362c231a9fa8902c2272f3f7c823b2cdbcc655fcfce06d618160e3ea657ccb8089d6500ca8ce03da
+d: 360f4f1a063342e223664ef3b1b952455417f74264decdeecbb36d6a79a7bd8cc08b3aa7254665c77bf5a44344e47eb45ab85b7a7572d192419cfce8a0e0a52ba700e698d907664faa6d507d21931cc25742fce2826c36ce05ad3a87624a1e93dd87ee780fb0f4ee5cf0589b5886dee3d07404290ab9b20297be4b549a35ac13f6b9404427730a587eafba24139bd65c7617e3f059605bbdda863e78eea09fbfb84e1d28b649b443dc563db6396fe093480e8f811c1b61f79f9d399b0f278852d94bc6b24bd2fdda16787b8da09894a895ec5d6208e61698c9e9f3d0c2c2b955de62c8787384e1999700a802942ff875ff65a011d6ad3aed56d8ce10fb72f521
+e: 1
+h: e0
+k: 20
+l: 4d5d512c676e7b4d78575f6d6a596c485265515f5f24247b6443583862202e6e606c274a7e40497d6f4f6437473b6e54602f707054425c4f6f28572e2033393d612633577573293d2b4965
+m: ad25b53fa6c0c01c57586d100a96e4ff6447a2ce7e361c7bba0858f023aaa2f1f5be1d6c159854c1bd0cb35fe7f84255d52f1df8b637ac26fcf73257430aafb7ef5226ecae49c826e773b6284cb9571951fae1ee48540bac1b673ebfca9f90b3e018fef04982d2
+n: b299f947dc23e3efb7a22f13ffb410dccff1e631bcfc68e9f754a237818ecfb3c881eb40d8fb543b066074c71db117b1245656941601c4ad05a7d6ac3434791b244f34f25aba01b79c8a1f7e8fd82097675fed1313ec09e36f2482eb038ae240dce1e4689c86f1cef569fbfed3cd74af3e6b8f4626ac6597e0bab33d199ecd4c21f4f034b1c81b4a810863feb7237c8e09cbf94803cdd055efcc99cd1b7fa16d4601b4e33546d5922371075514669f41bfe8b1614dff3e32eda5297429482818a5109a742058918ae299969592281a5f019f720b5e4c3354622c368521b6b9c4cdc1fc3116553d3242a82deff18688a2de77965cd5a91aca07d0a649efb26d73
+u: 16ef09c9a6c08075765bc3cc38a9a3c7a57c6afbf7935a71d6aeb622bea676004931d725a4dceefc3a803f14e16a8ed70c730005d20178ac732c12c755aeddc741f3bfc1312b2b36cddced80b073dec5cbe5b388f554f1d3b57e349c3955d8c2ef15161e85f97813dce43cd2fd4861d618eac268389d5147ca63673d86812289a1fba5918f215b5c5a197a4b4216ade6fe30547edd070568f84bb77dc87a497add308675d44742ce9d5acb3a4c543da5bded0b6ec2fc7aeb0b93b9559a469dfb32d97978a41ca424607e9ddd92a6ae30657c61b17637fe9007da4a6e002ac57e8ebc860dc89b7fbd3f1da7bc80a74576976667247c8e911f11222e8645143beef
+c: 1cced0c4a5a092b7729f011cb67ccbefaa6f1e03f31bfc7c015496a04e4dfe374af886dc59745a534205ca49d0cd9dac7981e8a0f53d0b032e5a2abef0efbaa24c80447df8ad6f44c1dfe6946a4b9c9d8d4305921f4fc4f33fe11e9e0b2fb45733d6a6214551c23a2dac09ef214726988546bdd7827d5bd730e65abebb291910dd569f8e348b998603ec57384d80978167aeb937c53a960e562cdbe71c946f69a867a7f8962128e549189abf1407110b1bf587c9ddc5cd2b845a74dbe5952e92cf752c403c77f8a1725ecd1af9b0791a9ba3b74f6f3ceae3e376e80728abf1ec178be929fc5f5fa51f138fb7ab91c382ba30590c700848b60ed5314a4b995567
+d: 8b53c837d8d93622a6bf731e1a1784540fc839265418ebb2633025a9baa425ac9c09b6af71e4de6fb63dd03d7944547020b7f1b13e16782a8a6cba3e5a342fd930e799d5a7fbb95ba4e569ca91b8e09ef6a2e2f5cca176af14230a417ff342a0232c4287eb9ba241638f8a768d36ac03d739a7f067b9d0198c1bef5ea9d56573411418a53b735fb64571c307097786f2a769fe22ba4e7c321fc5bfe94a30ece86edde6204fa9341251c37c5c3ac463249934b1e754d5ee1f7671bdda4fad0f7f3a3085cbe940f15487bf78b5a9ebdf2b3c41b6ca63fb4ea1d226a7a2074148c523c193e48aa9c5331f864347805af8fa157f694912ea87f86959c122b32b1c51
+e: 0
+h: 200
+k: 20
+l: 
+m: 75e7ab9cce3df0401da34d2ed46c2fa6984ba2b2ffb6393c30eb05556db182de648999e5fca9b8ef5c852c4b68f82bc63a6cd845ef2b070981a63cd76485704eacdbabfb
+n: a303b329a3e2daef31cc5d425b6065fd135567955f2d6678c746ab6e4cf8e18507d3680d6bc725abc37a64fb5607b8f17b1d5c84641b31c1ba5d20904b8c9e6993b972827b17df461bfe468bfea9b6edf6567575a0ce84d9ff4bf5bf2ab7a5574f5086ef17300620fccbc0aa579bdc8bcadd11ef1ffe35289ccddc9092a221d8fcc05469610aaa00435aa70fc73dbfa1e78edbb22ac3fabcc08c6e28e8f3c6099359a711901b95b9b015d9c57e8a49b6dd52179da06644919b455eb4780b4b927e70e41ed9c56ce9599e5e539a8bceb2af89aea822349eff4b27dd3906f56da6471ca851ffa4daa0b2c04f30b55773756345a09b2c4d759998f92d04d00650af
+u: 192069484583bfd32ca7a6127ab6228ec28439cba0917bc391348bbfe1d02024926aec51fc2e32a59009f5d34b398b9911619ff084de127856b528e962838a3bfaad6ca42b2673f24c77cb33070ce311d0b673a9a0352d01de49d311914d0f68a3536e9ce77dfd501800f1421885c1b0d5572c488ead2967e71b11ab0ef1a9e8c9bab09d4a896eaf7e659a89f8bc6edb54cc1d07cbb9c582ae9a100f8b7bbd23f8b625dc5d72cc019a729769920527d50143f82577551758961e177404a36a50631eb4738d2fc76dc30e5d55b6bb36e0b6f98217a4788abd4e844df7e871d9a6a054e98988933efd4d5e9db90f858923e1366ae615ac1c486587bbe20538ae12b
+c: a1d200cb7102dd3c8f98a662feef29f592654d7a2734e2a334352e411a3a0da596ff2b1f24f042eefe8711d147aad126be80ce885c9ea701052af05509726f1c67ca709b734fc4980cc899c34e389a1b0fcc8238b3d6aa248be0e29845a285001400c466b7baaa25b6a80c90cff844dd5c9e07de4e021583de485e7b50057fe6cc1093af4f388630b738c010640a54600ac5474e8a947f942a9f7062c1b5986f0ac1e6a0e5eb27d28348b58dfa80125e1245a5d30aa3e0feaaf73e15130459d09ceec56f09148cdc8aec87247e6fe3ba7db6ea006cf20dbbe4d29517c48e2115b0e5e8f778976e812539afce5564368fce3bd84b2066a21e0a5e379103459096
+d: 966a06b24919bf22be3f4c9e796d6b8b995f8ed10b9a63db3a2ece36f7f0f4444ac8fd0f4afa515820f55f3e36c97195a4da1697e13122d933dd47fa31e1299ede7939b695f7e13910da50f0a6e175193e94c52c0e1e8a3200de2a8a16b8723c0873cfe18c1df21fcc3193651cf73081d15b94e607d60edff3d0177188d343ed60c627e3ab4451c25ce9990f0307518cd72ec3ca6b92c1c7751fd7294d7e525640904687bfa05a8bb31b4f2dcb8775f86767d1f19e5379348311894d1115c193d358a59a85cf7cccd27568a70364d0a455256ead303ae01787362db98a7d8b5185a11a7c45cf995b0bb5eb1a2a20ad19990df2b52e30b45d8537f7ff25772fe1
+e: 1
+h: 180
+k: 20
+l: 7a6d
+m: 1c51873db0899e92c540f8f74c5a6eb27a5171dd2e2bb46e2099c3ee37b216dc0fc9eb183719a476502e790ec62b003be962c0e9880f9ef1642f722c1d9cc77a74a610bc119eb52c920ce93f0b87fed1dccecd38d314129323c2918b28baf6b5e3dea85552be0e12b880c0f6cf75f63b5207deea4dd14b75cbea7aac137c3aff675266c5f8a0400f7d050f6d757bf0edc836daf3d8eda394fe1a0f8a2b39
+n: aee0bef1c2ef623afb74430a67a0a6a8ddc8f78867ecd9bec41a2dd4f27f6d2b76614e38370395af78b02cc6ffee29a43588b5d9c96cc16c9606b62cec84c144b322af2edf14ac7d9750c75e07f065326c4057c82c3108104a68a48338059976d03a2b49652d879831173eff91f846ecb880194b5e9d110b57dfade5a21cd2e60d221ccfd4a5a452f9715289822a39ac9280dd8574fa45d4bff31a355d45ebe141fe24e1586d83bfa01169fcd5c6988653eddddcf22a3c61f14063afa7adf0630fedd3395e01e80db318192600a4a095df7eea75e339f7fe7e62edc5b744d60efecc1bee0efa566dfb8b1f7b1dbb1e751207e841533b306766e90a7d17a91dfd
+u: 176c0bc154afe92115b9e48aa977153ab874d26c7f936cb8ec54f517c71cd77c6df6d6cda9c52edb3b0838cec9e3654cb1c7d3e83ee9bf2dbbf405913b6a2223f8c43b64e8dbbc208dc1ee2b055d095d351f62ca8cd3a6c5ad2cefbfcc3292f1c220769873331a157161433cce77c6e1e6b952d8e058212a2988c9cd0139e9c14cfc130d1d74916c494d7b601192ab5a5ba82e5fdf87807336ff8314d01e7674488b9cd47ad38d4d45be9a7d0cdffa77d52582a3b75a43cb489825da184cc755ce7972c5496412e40df14b932eca72a95b55bc63c539bccf6d6914b6a54d73fb6c5f39e76d77f63da4d260b7b3329e8b774665ea40153e63ea77dc2cfc6a0b201
+c: 4a02a1f4f709f520326e5f7d54e0ccd98a6ef3f0f8726f07c78aa810beccfbbe6beb181110988b74bfaa5dab5a942ca5fe42e72885dd0851bf541fa2b0dae077fc3aeeea603583e22c4ed4b22c7af6ec723edbc29a048abe1bce8bf6647309b95212976dd70f64b01ee8093e743b3dfe517680613986a6e7f512f5a77332c9629cd69ff2926dfd3176232bdbcaee4268c841f043506f99a6f0a2aa8716da53f72d5ec1f5100e87294a56f2360eff510a2eef78094aa2983b6359d61c90bf19772d6200e2bdab23de6ac4e4a26f853cfc7aad1ee39515db94f685d9043b78ba514944349dbd6ed2bdc6348b64af340970cd82b2325e83f04519c77f91318baea4
+d: edebcf2d191e655a88890863631fd76a90816c3067c82182d3e3bdaeed004ecdace88e69f215d9b3b01e2169b69b810e2fc19e4514d6a6f8e4b9ac4fd46cec9ff386f37ae4e5785503d4d5e7a1c64e09dd101a387e8160a4f3a6de438e6dfebd85300599f685e73eb6e0a394b09e76b3a45bfbd196d078f4b57ce7fe2f2a994ba619c328e06fcc2c57da88cec0d8575cafe2f12c8b02012aec73f766b096f71f786a9edc97f34e5c1dca594c1072ff0f39fccd6b0a44dc3cb3f7f60410e7a7970b0d3805c58b3bc5c64646028031963672aeee8cc3d15393a20e3209a308f70a36189eb7953da7f824cf6808ed85000db87f5eb9d8abddd8885d3c5caa08481
+e: 1
+h: 180
+k: 20
+l: 7c53775821543922775b6e314b344b3c6a347024716c233d3269556c344a2378495e
+m: f3d96718bcf58550f535e2f8f07aaf31ebbc512da796d19f79caccbfedaa8748346e361898c83dfcc89b3400b1bc8a6d65af361658281dad05d4519af450e8923fe26524378ee2e17008e0aaf9ea6cc887c5ffb7aa34c6c9e1c23560fdf541ac05308e357bc8f8347eb514c3de518d30fbcf13
+n: a85f59c422e27354b18bfd1d7d16fbf5ac15edbd00dd2c427de52836413c7e88ec288051079b5dcaf3aa3e4bf6d09020557eb63e6a94c6b8bc06c51cd6f2340ca6690522be46abc59b45c6d8863b0bb8a4f589aa70adff0b60fbcdb21a522051bf32738e0de33ea44350bf6540b7653f3c04b056089611e20d67eea6034c191a095a47c429f0db228ca1f1f81b1d4796fecd927a98908a49d582a9f04975612407f04f42b07843cb243e27b72780438fc9075c62b647dcc88974382a3be7a70734e088aca0a863eaf14e397b1d288f22f109e85a4e057098c649826da6c04c388943f8753433134d6cb75a2c9601c860ba6e1f0a338a1d91d4b51032653ca8bb
+u: 1853b778a49fc8f293492e1f88d8eb7390e3b3ba5d5470779909ebd9a496f1ca9010444bc8355c6d5a7d223071bb14d0ae51684d3f11552568115eece720ab34ff55aa2d0556e83c4c7b5194f59fdc0e08b9fb8867f18f5c6bc77822ae19d1ba9c9089b1b3e309c1cd67bbf1bfd6949adbe62ed9624d555e0f015b6be458f8bd6612dee0271881785369322e0d5f52346515d6ff09ebe1b0553e6c29a3da0ccfbc767c3956e0a54089be492b32897bae967b9ba02e762501934620a345045325e9722711773573108bea6059f864cb44a85a6997b78d51d332fa2637c541d726a847b225e57bba2da5281ca491bed5721889a36b564791165dedf6c861c046ab2
+c: 6c27391af61249c135c1187293c06a08e145fda1ad87c728dabb9e66be6c69c0f4895a77ecf9cca1538c83a70ee31388f9d1053c47c047a63d4cc9061973cd2f9c7f25ba4c11f453a3fdc39f081670d12d9d280f31697e5dc3574f1ff139be7c114f505093fdc545161c4e92315d22b15f5c69fe04103e0a6beab775983adcaf5235729407591e5a01cffa181fb95a34dae229fcfb0ebcd65893b4807b803eb2094008571f1c0df178fdeea77b1a9680e5ba615e20561246e68ec76bea71ffac877fb1b2e2282dc79f531f37fc56bd04349800338bc450dc56dc64d91dbc2cd7bfbd58b1b3b81f74b24541dd67e58e1dc9e05b0f565995bfc9a0e90031dbc6bb
+d: 654665a9df90369c853a6b51289785185b132be0a962dded5b5049836c157e8d836ba80d795a4146cfdc4532f11082c3500b70400b9293c55afe17fcc5373f752c4aafb30f67bb1556fed7a700dfe2d3c4ba88f1d7b502997074c122e0aeff891f4e5a25d1065d86f4159107ae522bcd8a7ed4a534327be8cd5d1b3ae7d919b13c82003facc65ed5e95aff1c9e3848f822d5348662c7626696067e8321adda999236efa7417b4e927f41de7f74d72db14fd76167eff450e56de26fd32aa1c8cd08c519bba168afd9305b75c069e21fc8498b65aab3b8a04813303de1fec7357a3de4495e07ce26d0234cfe4dc3eb93b97923f683a436c06bc9c6174be628b9a1
+e: 1
+h: 200
+k: 20
+l: 673d3028786c4f6a656163333938552a
+m: 7ee30839c986572f0dae98
+n: af7efa3c16cfd1f30799dfdbbec099ae2dba3f00fbb80741fddf456b80436fa7348fcb88fc2e35745a052db9b32ec916e5dd130ec83703624d9f407c8767c22292e94f817f23912fcd7377e741a69f1122c7db42cccacfe049bde46160521842b4dc915ec252addc8ab640e8a11ccbb70bf84e014e2a4af7b24760176a07366acf2be6db99786802dc38ab5252373e56f9ecb86691d20f9eb84671cd79216ddd64de6acc000c52be7e3e790a7f6e583e118879f35a27689e3dd3d5e3391d3696a56bd9080d32dd1479b0aa0ac603dd29c23e60c9ac15a5bddaa4f65d28ad36e4784ea81cba10875d297fc6e30e7d786e9a16d8f6e09df5abdf8eba742401891f
+u: 1756ed91d99d0edac5cb73d965503a56278d7ed47bf9f303537e0ca521d9213d13d1e454906c054ddabe806f834280ef26e60d247cb3e9e2e61d1386d004e98b0638c9d3eec4120a059d1ebbb50709419cc346f1627f8a52aec23e8a6f0f58ac8aa6ce1f0b0c47b6f0707825512e4b172b6a33488f7a6b2889654cab5886ce5a528e7e62ac6c37f66d06515b1239ed93b75669e43fe67bfb7a5d73642ce8ce8e9ae046e0d9fde7e024ea1143f20cf2b8979c6ca8d6a0ef963978e7c9e89f22407c1e5303792b405af9c8cec434ddcacf06ff6e80116895bde77ae0340d07a1a6c2d606244e72f730a6552e19cf41fcc33a2d440d5f4adae471fa6c9ac4dc88f8c
+c: b5763fe936d7ab91577ace6f96638c0b44a7c8a1be7641c66e11fde685db2a0b63b002668af2b2a34a98fba2962d56e3e9540aa44dfd5873a13929226d3bec9f2215ce2cc0be0189ffbe34a9d153eb42791dd9990338cd37a544aa8d57b7991b4974d2a788a575bfc5e11ee6f2aec33c4ada78d6d405b5604f84fe3e223228122bcae150c972c6455257e1f749ac6e3bd72c8531b27375801b8be9ca9574208c9efb0b469c09fc0c4005651e205c88f9d722abd1f06ecea9544958472d4d093a8f4bf21aebb183566a2148cc7ac10e5d0cbb9104d568ca45ddce1ca29d084cf3e5cb3fbc788e56ae329cdeb0d1485147ff8fec925479bae4bcdb303cda50fa1c
+d: 7688ae54bf5a33f44cbc916130c032be30ff923e5a6823694322b34821e5efd1d2d2978b8de12ae05dcac2504e35c458348fdaeb689b0b918cd1ab31ec10b4709ab4f28141c69a173bebbe2d87087bb75807c012ba9afde66fa2863605ee6aeb471acf6297eb1d2c46cfdb361e3d53299248921c107aa89b5bea65edcb4d160e9805597b485b4bd20d67e1099562a8a77d883db9304dad879c0fd7fee9c5aad7cbe7a79d5fceff1d432bffdca7c6b93bfabef930a9f9a411646ce9f39f65bebdde6c3ccf7ca867dd66a00d6f251c3ce20dd79b960c1985486c715d83cd8eafcb66b61aa9d190f8a292dd23884b279ea13dce2737853fb5444d2344d42aa46e01
+e: 1
+h: 100
+k: 20
+l: 26453725372c3f7646357930684073595c5b49424478423b3526676f504c676c4f5a3b3b4b2a6f56692e7c262b53453b407c7456785e5d314d415b6e627433544e415f754255433c777b207b6f44322e6b5f39576b7e6f5b4b6d6e3a275c405d512a2a3a5421734d
+m: ab
+n: c319fca097858dc3f0db9ddf6aa4096d93294dda718bef5ea3587074b04839ea24e507edac26f794b5d176ee8593f6b3f07e1db646fbd0c944d5b0282a8dcc2caa849ef305543e6720bd09ccd7ae63cbd7cc2763c1b90fa39b37fadc282c7f3c74b85c34f2bbf6eaf18dd051bd73b4d1f7dfc73ec62f5720073ceaee9a7ddbadbabf2d7d6df29762b81cb6a5d077687337d0c40616ab750aee4bb62de63da7bebe30b96843b86b51cfaa27282907e81a204c7af79edc5f44a4b48d41eccf946f377ad8f9a79aef8d26eb2294c69c536647cfe1bae7c453b05005d4b000037641db27c495d8880e5fd38a77b39b3a49b0c7729d88f9b70bc5d7ad63cd63c7185b
+u: 14fe83d7d97497034b8114df0a6cad7ada5173b7190fa79999bea92899d4f5bf85e4575adb7f08595219a746e26a147c75ef91e1f4a0a82fe7b245b9d683e0082930072be7f46e6c9e8fcdeece9906d3cf5c6d5636b8aed0d616469f9dd07de1d843021f9042848cd6615a32d1184ebafade13749a00df3e007c09cfae962643368ae1ce1aec49660287518c0770eed15e89ef66d955a51fba80e4d5cdb0d07f849e5ec8c504892bdc1daad5eb9b5d9dbbaddd516cfe64bfd1111168c326aa4b668119751f92d9df39518533b2fbac220d5de0c93608035ba9e1c5fa016a5d1abb347f421561bb45bbfd2beba151c141727f7b44a0245d7db6a58623827ded52d
+c: 4432da39ce09dcec2aa8a868c73082f4595b168d3bb826f8f392d5ee5ef202ea97ea7dc03210e37d7f2e5b2d63a5fc78da8a909a4df98399b5025cbb30ad3cfb7c420f072a184eea9315313e93f70941f37e7d009418fb7c6ca2f92cc21aa967f48b16721d579e76a115d0339d42f3cf6eb87891adcf834241a8d292757e3ae9acb7b1c72ac98f7090ec79b4b9f839d14bd51ed7bbf3e7255aae5b932cf81f547199c57946fbf07a5e57acc3c1174832364db1780bf722851f5fcd06226204fa936273fd1e590a4e3bfc730b8605139f90c164acb6203c2db3cb104b655c08b213221ace7f4231985ab5eac422c21b80c82644042d3c9d5345a00d75668b1e24
+d: 9ba3b244a05d94f9581d8ad37890c7186cf808919565b64538d4a44f3e705f5ff3b593b3655dbf8de43b4ef976d7c5e28e64cbed6d9b0a6a283ad4801d9839b83980c27d9c3cbb8585c68e5a7a8db17d4a093bb09fc94ac7deefa45d783ed3120fd72e75046c7e070ff77ebc4534196fb1073954f8bad3a687ededfffc6d4008c301668e99fbbfa9966048d1db62d75134d5e9d15a718240516fac2608845e6f1d7314859c7bb4ebafdaa51f88bb63b72d856b7026a2d15d3433fb55ac0c6e1261562182fe5897bb500bb922cd3fa589bc357e07d08d101a15ee23d37a439152cf6de490bd925d59416a51cbd3c26926fb8fbea431fe734c67a1d0bcb5092501
+e: 0
+h: 180
+k: 20
+l: 
+m: 2b29acc34807948a62d933b97ad75d04a583c7b951e696bbeb5e99302726ab99582835150a3a2530fffc05a9cd6cde16b24305c74db568d380f82876dc44a49f59d58c1f72144e80fa2b752a660e3e50742b7f5abe14bce973f4241c3dbd1679d0d4d7beb1613dd65d3b2880
+n: c2202f47cee661160bf5e15e7f15d34ca5f737dc995ed93b796c07a88ca06b08333e1656a697b8ce9885b4cc445f166c4c6e32ea2436378743386c2cd566638c90f5b0ca847e66991b7fa15e85f6dc31de5b13ed1cf819a70631e80ddbf7a2d9814ad3c81f086e5263266cc386f08efc4f281e62275d9ad29c01d2630d510dfd64640df58b51dbf3c93ba5b707253456024812fb8e2ff757335d74f0f4c42dfbe83acb29c5375c3ceaf0bba413f1ad448be5436dbb9e682846832de6a36d1575a00cdc8295db95ca49f628d2de5bf72ded20f81645b24916643ce68d725930ea646b95955569a06dcb62cfdf305ecafc6cbe938d758119f5226cde5505669a49
+u: 151987cd16d386f4b1c1ee2f93a286180721ae6e8e0d62ab0bc2479640df651be311a8a6cb6e0197948f1a096f9ed854fb218ca4ff3a382d8313c84e346d3334cc2f0ec094b6df32f3d48949cc78fe76f89fdd300170a4f46c7b1f1aeba03f3e8135f1d004d553d60162df780aad2f6e344b800cc3d003fea59d2027306defb7f571517907384376a3ba9a3dc5ac25c48157c74156a3a746fb4767ec3f2f68e9d633b69f0430af4f72d976dcaae9fa24443248dca0767ebf8bccea121949f7fdb29827ad6a2d0eb8a78c4bb068ededa8cd7566fb38c81d3c9d095c0aa12fdca7d880897fcc4a410dc88fb03ede0cc26f656674262fef67c0a0f1b2c88face93c0
+c: 202c595af42dbc433f519c9fa550441023b539e08410a776f9c5a64ff2f3042e6446266e032b00f1ae240406962cd3e4bc09129763981301899c76358af0bd34190a5d86367f235373d97693b677b85fdd2e6d3818f018e9734b769d2fc565c6f75f99dd869dac4eb457b5c305c68e84113f059d69023e096ce59c671d03fa8895e60d163712ac7f54fc76c2178dacfa45c218de97d47f2de8b681447864047b7fee5e4f656cbeb0f951d7d0cb6bec4dc8fea5cac93d807b4566563858aeedffae2e915b2ea2b7b596a57c7eb6ab15b03ecdeb7521ef3eacae00eb89c3209554d2410204df53ddb5f1d78d4011055eb8795fce0050bc07fa3001a0bf6f83908e
+d: 8d7d0db83df3b01e3c70cc099a5073fa8e42760c8b6f5640891fa6b898d8b277935f0efb9b01400577a0f40f5734bb904b9687037dc8fc4e66ab9522b7defdd5b32140c4fa57331208d68eed980dd590b4fdd217be65e7c78556774c7bf0fcf78b7116332b88a3c8e7b9db052d88eb86503486a4fa7964cda772bfa73cadceb60fac8f5c9d48d560570a6d0206e43dbf0a05e8de5a6d78ac0c26bb8724b0d463c1166ccfb8edcace33005436c309c23610a2d54448f936a0926de86f0abf885998c7b1b861118677235748b7b3c91b624f7424bdd226b9e114f83ea5369c161da666fae4f9cac37c7dcfd0cc89efc891f65338e502af32073362d49a4d9a661
+e: 0
+h: 200
+k: 20
+l: 
+m: f1c15b1f0845e646ae11b84609918665a0d905786cb258626c4d8cf1d1936f0553230f8c0856c8ada90073aebc72fe00bea63916fa0857a446f1f2142d2a784d4fa77c20a006cc75d59bb67c70a51dbacf264db1959605cc7fd53c6dc6
+n: ced536f088ee2c527b3e5bb260a0e18c2a029530cbe63ec40fe5f5e7e0ab765129f940a79e0a6313810aaa3626c2e4cd6cf1abba975e6f98c6c5afae9404b12e24dbef0ac0c137f7923af9434884306a0aae5c9532f7a13dd624e43e0ddf6f2581c902378f0d0fa1c75ed9cdfb54614c2c30bc5aa387f1c99e0f92832d40eeda51eee964c0db931d52e62eecdd64312c5d7f8c0ef6f19f430a04c89fc1e93b0037169e382fa92f298304cbb4d0f644924b1976736a7b32ab14bd4e07f56da53519f27fe3d536ad1a9df220aa7d6756c14872d0eca9b0bc1f6c4f0e6e09a14f64852177f6042fb0f784d0b9327246a001589c27e80e377e1626da46bca093132f
+u: 13cdad820aeb093374c550797a31cc5ed66f1b9bfccd215654e719fa826c6ab49b7dfa0a1194aa3ff8b1350a4d8a6d68bf46834f452ad025714c70b2616bc73e36febe1a454f1a8fcdcf93e32679a0672cd27f46e48f1211a05e2d45363ff1a5f5079f03bacc0cbecdd76dc73b7078fb5a7f560f9248bcf22cda90f444bd2b03ab0d3093ac0ccd97811bb3dd9016b97b44d18aa1d72fba86a4c7e931bfe74fa7a22bb53bf6ab8f954af543384e757eaa83f50086f9a2ad73f0f43c0f582a5a0dda7d6c12cdc796c3150719368ef00cbdc88e7208a78368e7e6e5dc3cc315f8a8dfebcad7a2dbe230bac6ff4ff75c21c95f90bb5b48ab438ec7d1e83595840aaf6
+c: 71019b5b8d5fa06d0f519a18f44930af072bfe5ea26da100b28b1dd42c4ac4d7bfe858dc9578bf04992fee2fb2a1450936fa7815d1a15b15db2e0119c72cde326858cf708e3875d7806586e28e5ce9fb2682f6d458256b0d287eeabb0fc853181e7445a0f0c5f15c57e197f80101afbe3d46c28b37d273f8af5f1946139b53d3e3add5d8f669d587346ee73aa179ad262c4aa476be3d01ec37d379ff27d26e966ec07df95a1c5bb0a1381f552e4b3185b4f2824f53dde1b9d3e7a1b48a06d7eabbe7d3d10b4e29b55e4ac876af26695c5efc74993863144dff2e2da126d1c69d8edd148f9fabcbcef9b9ce30c694f099abf0bd1960971263417e1d632c7bd7cd
+d: 3f6daede14a35344fc7cf08da35ae5e0c96db38fcf6cc31f69caf13c0f6978193fc48d1fe796996431e78a25f1904d25794672cac8f15824c81ce6240a217fde6a5c07ff6d8f4d281f0e154c6d54719611a60a23b22fff64307fdceda22e3778fe48ea8aa65ff848093fed0e96aac7e47fe69d08918db93f58404205b8759b6c2c944f4df917b0aa536ccbbc9df19e115875b853e6dc7b51bbba2fd93ef9f84c0a41cdb2a86b2f3f3c9c3d0dc585dae186db77f920988f6ee4bd15a08b3c1d00bfd7400e259e904728c14f79f0717699328245bb12f93d13e9c0cb3951f8d962dcd7413b429d6fa465fc60173e1bf10f3881a68de7b74bfbe71f6a052ee6d2f9
+e: 1
+h: 180
+k: 20
+l: 2b57202a347a587c7230755a7867532520434f6e42227743347a257735695d677934233b5f7c3f516827473f7d7c4d7a3f443177265f4f264e277b784c28503133342535614760
+m: d5ec23d3763d580d4f11b2d0b87db77408e6281aaac0b5de4eb6ff8735ef2935f78c7cd8373b248af09ba98a4a1c7c253c739391dcfa9b56708db1bb2f9a38f0c75b592c75ceb78c2e35ce0afb4b72fc08e0a867085665ef452082b456fd7e630a1e3acc0d25b444ec4a46db91ab2f7c2f05dca18c7b50b813aeea964cb11135a2fa7a50fd
+n: f682bea438eb9c3bee7ad4d9457e099ebd2a2c5253c742d867ff13098745b0762b0cfe52624299769989ccdcab4712e5aac5919746bb23b92361e83d9434ebe9fda376067da680b279168ca564a62fdbdb7205c3cbe4c23347c31d65f5572e1fa24525c782760f0789b5311e6f1dd6e8a9d55ae8576ae71a9adf49eab1659b1477f0a494358906e7f4760d930aadcf8fb7c106a9180404d3636ad75a3f542f18fc63786fc7f85a64bbbfaacb81796c1736b5c31541ffad2b04dbb02311e8e0fac86495ccf2c14f6d7a490b51c268e8436d47d2d59983bf3f59d377054e207c85b0977b5734a13cba0fef2ece435c1f9a4862e4977ea2cb94b50c2a74fb156127
+u: 109dac49b511e3a2374d681f13fc3e704469feef7129322a357224624ffc629cf90ad8151d0bb7c31f17d266868a412f8dd559b88a28783ded330bce3fea505ce33560ac35efb43db1c9e20fd8e2facf0f442964da6fa1a26de13895c71dfd2a61380302e0b808d87a8d94bebd33ada9ffd23d45539b9e0dc6ffa15235084570548abd77e6498e0dc9ff473515c701fe9190b2cac33d47185ef5d0617582e5c1a10a4111d07a0d3be6372dd41cb639e018ffe11b31044056281ee6c5a575e0466d713c96af92bdd4be477e4005cb6e745add64e9cc2603c781055164e647dff7f74b906e9ec5aa6c2af49f566dabbc3e28380887914057fb65a5b9d2eb5f5d196
+c: 8abe2169bc367f7fcda63e5c45b2c407fdea674bcba9e7eed1973e747c3801884361e12bec0545af2f04ff64d8b5f3f42259446a5f1e058d7fb213b418c03579387648d315d2fed0517193933c12981ce201807dcab637eeb5cec037331b4dcec7e49733b262c38d87bc6ebf1b1d27f28c2907ff16656c73c99a6d69f7659826267b48e139e366446622d902f10cae0de8e80539ec373704ab0fa72e6def7428e6c86a8192d157f77cbe3f4ebd3b6f231a33f572fc75fa58da07b3d703604113c1e5146a23a750c3a18ec4e875677a4850c84f2b29a3bbf84e51484f4ac3dcd537235c106cad4d60e629bbe8695df505fdb3f770d38da07d7797481d70ca0dfe
+d: 48aa68f885c559aac9f22204103e13678b56646fc09ccb4ed50b59d0da06859e58d3aa319db265c4367d8694dcff8060f0b8a4c08221e79fc46d2cffeb842cfe57b1a8fd5fb15dd90a36927d54157c1035fc7a57ee14fd41b6947f351c53b0210b74b4fce0dc0016157ed6e7e6ed1035482f5bf1c864ad832b73fcb28100084addc05fd08c0bec0a8c96f03545b19befcbb037f51b682440a3d77c1bb9636db62b10b25dec16e2690c55f28fab721b5f2522574a58ba090930905c537f6672e71702f3f8b65220b02779c87e20d0854cfae1cdf2fbd909f74b4816a036bdbf337098b0b0b9dd41ff3bfff9d9469f95c8e5c916e319be043faee440eb7b546b41
+e: 0
+h: 180
+k: 20
+l: 
+m: 10064bf2396cc9a5d15d6dcc98e9dc4e50d525934c6df2a5e17133c2c92039b02bff0cca436a4c314a430b5027b1798663dc94af8224d678418668cc9a346cf0afba5e5657c178dd46b7c3e31cde27f821d25a8a7bc134f09d73e8895625f938911f61bfd3e66d9570d7639343378ace3d975f91ab7f638751a5f6606feb49c02030fa
+n: c4e2eee2a603f93a556647f352c9a358825ebe519739ff87c5af7778bce46fa58e4f32d0cb96e05c6b8ca5fa88c9d3622fc54c00eb688b371eea20bc90d445f6d21106a2e997680aec4f62b969922f38b55409de4e49876a83639747b5ec10a53ab1e583d9d2b625bcbd48c2b7df0dde4e33198a45131228fd93f66a9344a3891459aa78f6774cc8ed376dc5e6587ba35d2891e5336dbb2768dfdd39eb50b2ce42dae8b86d107e907ea2de7079dcccf2ec696157a49f5b97434bbd4b07415aeb6b4a49960fa877b97bf9d0402a73098b9ec60b904ce2a3664b376cea06007dde489fcfe2131802fd25a0d638cabeef75312e1cc25a138b9b39096a99fcf4973f
+u: 14cdca55bad4dc86096ccd5197d84546bb46df39c45d774043581ef73d0f21d5cfdd12e7364e2b61e59bc035c8df76b8dcab946bacee6788177fa6e63110f4d20b95ba21867f131bc3cf997a2b9a417158e1201a0ef059036267a5fc900e818aab4c0d58f5f4a90bd68dd60e9d2ead7c553c1a412983a0ca5de615547b68ce3134a2c883b65560b5b998d3806c75285a08213c8e2cdbfc573ba86b362030d0e7019e4afdcbab220c240b1dd11c845f1f09830330f001868c199907fbd86f3544499055f0e6a41cd57c2103a238ac26a1bd39fd05517e337ac527c661394aa808d9001712bd4db461cec24cfaaf491e633aba23cf986bc40123bdabfbe6397c208
+c: 4d0275192c59da1db97c9a1e45373baa1ff7f1cee7ed930e2ddf37873ab2a58a292d21cff4a74d2ebf57dc0f198141a2624c87bb229bb506efc4f539ee295697b39bdd6a6f00ab5f74ad0315ecbaa4e959cdce131d8d540aeccc85cd68be1bd2dcb34e00f3ccb2bba7126f67f9ae8b5ecb52fbe1bfa848758a8ff3ae2efad42e2c804bdfbbfeb173af701c9f6c0e2addb5dd8b123fb3ff58eadf21982255cefdb1e01db086488608079a0540e2e7284c9c4c79eccddab7685116b2956def0a7cde7cf41818e6bf55e2a99468f85cc8c77306802a9c37e4c6e3f4bdc282f87e11f5b50ce7fee32e44a3d96f12ffe3ce02e8a5a03f17ee173e7686e85218d2282a
+d: 19717b8e8a669f5308a8760968ae52ca5fa0eb3e1fd68993a942870964030c7ab2fcb8c07751bf2f15abaaf8d9f9dc18dcea85754c4afab4702673ad8138b70f68e98b42a39381afa7431bd1bcdab17425260505ae4bc8c4cedcf89691ae1a64e3b924a68db301085c8b638aa56e7aadbec140b67249744a1e30766add05c597fbce373e641a49a561980f42e3e45bc83a1d575fe20c7ed5b2936185fd604a74c25537c3d2d9e32fea171bdf6a9bedff61c903dde69848808c0746c9133fbcd9fcc61b66c523c55577b4b218b55c940ea700a5f825fd596a91ebe6b6e0d12e31da291394582a6fab356d6040ef3f00884f300a5fc2fbb0bf45b1900837ee5295
+e: 0
+h: 180
+k: 20
+l: 
+m: ec8168d36590eba8d627e4ba1a1839c3e1019b1f9fb08d744012af88c2d1fd428e03138e0942a69c04e8fe76d50b9769fa7ec15202aac85898e72faa1d27fb68d93d2fddbd76fd01eb1e48515b2bea6ac2b4298d7b4b661616e1c6f6393de0f12350f9dfd5d194e2e0da1fb708055419d7a3e6d0fd1b0cb758abdc33fd983dab5767ab67a776d0706b9259c1717678
+n: c95c9e679f75ce27e0f253967b372a57cf223fb7234b225a0c3f71ea8423ffce85587fc621847b8f011af2328b031011188ec5e82068167ccbc06f69c8fac8c2a273cf48f3cb1d3019ce52d071a75907191392ecf77b6947ed030b2552585adb3f289a11134ec2cd221730323c11ef01108211fb944ac4a99c1a7b33f30923850f5bdcafb7904b1976c480d480e67ad30b5c66ad730c895caf6d047f266b7b1b76c29d289ffc2c23fbc8cd8f54bf7940872207cd96f8bd31e1010732251c3d345d8168a3ae3ac5f692799435a406a4a91e16cfd54b8437a2b0775b5ae72d466627bf31bac8d583db3c7bb166c213d469eb5affddb5d1d4799305fe468d11b451
+u: 14576c40d6062f2894f649dfe958dad44e2485a94b10e350f64782a4b5c13ff8e387963553f7d3d35c559361519302e6dfcdc2040b1c29e9e9ed2b39a9aa1149ecbbdd2a00afcc1f7a0dc4b6ac58d125925b782d450baed27ab9b45ac1703e6a96cb9807403717557d8df1b4c15368c8728552ccdc1b2e412864ea9d4320d062be1e7044b84985fcbb6481e5f7ee0110605b6e89ec8e1a7b1ac8986d26c937e03ad45b8a1e22794b83075da7a785d0f95ca7b9570c6b2d6be441e9c6c9607460b413220743c035ec4df22b726bb28e411d92efd9af9df9c15813d6b371f77ab0500b664805dc71685d0ade2b81e2d7b2792eda182dda10a77eeb89d8bed28b10c
+c: 09895d365a273e40245a4a5de7e67b4b9a38effafd1fa4d65f21e42256a3c46575b36bc0b03e1bc87de19ef921274d06771a7d892ea2aac6d4877f31b3a3a2e066bc7e656ce5fbf70fdaab0fe81b213075cd1722e6fe5422adf8fce04d9350fbb1c0e388af92af4bd66eb2dcd4d3d349e1d772c3091a3c85922e92cd8da11728d8b5a71fab5a462f5b8f08857469994e95a14bcc883b55a00858f0dd8aa704b0f832748f635ac61c903f816221100b05876a68f914a7de7176e305e8a91601bda8db0c670cf365f5a27a2150c2d08ae30f43b1fb97033e776876c5bb9e0500b95a5829446e5c0f1b022f0d459089046fb85ba3c9e748d4359b4263eb8de072fb
+d: 6b934cd9e832746db36b6ada7a7eefa18d4b269c70101ab2820133c60a742beea396529dbee89cde1b163be5d62785706e4569fb2be4b1ab262f4da0ce133bd9763d8e50aa793402b5046d9b91060c6361a554f0a1297ff45a6dc2c1a383ec87cc81d5b721c1d2654bd6f10d0e9f0fdcd213894f2a0139ccdc33cb8ae7a91a5ca4138e60e919b6f88184e34a5642c8c66000838b35c509e81f192c260ef014b716ab671e587127723f14170c564127da4e4d04943a5a0caea98d85b017fee918a7f3eb65d62c296c14f0d580d0fab9dfb9edd7c129916904f227349ac706fd127ae8b00e50588d0f55d5ec2a80e7f39f2deb3af9e08e2dbd9a259b0a513fea21
+e: 1
+h: e0
+k: 20
+l: 3a615829456d3c59684d7d3422575138464b544a75305f4452323c6f756d2e3359362b6478635c3c73705255656a7d3f29702d237151434826393727572e5e212061275e386c54
+m: d8768462809484cdba497330f540e2eef9a57f0f9141c3228188ae00dfce038d5328fbf1d61439f0a9001d399f7a3d0a97cd325689bccbba42353779e9cd76f3b6da22f940aabeac079d48670357226eca0f8d71be6cd3bf56b6884856e22bf91b473c5d8a639825
+n: c9ace6a08789c0685689a1c05414492cfc2eb87357e53f3f1d8a060ed6950e81706a8d5d77dddf726695879bf3da883cf4842b2e5e6877bee954c1817482a860900d6401696c0894fcf6400feccbcbfcc371830dae24c51f14f95fbcca7352f7e88500d787619e20c3e11a6830b6c5d6dbc85e9346d12542ab55de5569160eaa7686e2d1d16258c33a60963151aa88cc3d84ab7e7de2ca01e948b669f37c78f4a21dd635c3df2091d1f16fb3adfb4e977c2ff53e78fb44a11c80de1ec975cb28725da672c66676ee18b2b40b45986f902b9104898c7cb6e2a0402eb8657a1fce0df91e9188921e9b088a8967af634404edcfa9fd72b40f8470167825c5207431
+u: 144f534db9724e282e577d03360192591e6bf1c190e716e4d22ef5f0f215976eaa999dee44c807fcb2e853b353e1e708c30d5cb9f2666dd0611d558423504bf589acd50c1fcca14f48b159c27f6ec02b5ce484a33bcbd9cc98179b9dd7361c036ff78ff7a7ca20babd0c51e0e5313ff1127f01cd1a2e0aecc5dd091076b05958e1b297647aac36b792bfd2c87881e11507ea7ff3d0ff9f5efdfb00641de16cc73d05894640baa9b4d92a2acf29deb838f622b7fae42082275d74ec812a01756019732de62c39a809d2dc6e195976c69645f8a5b47ba9c4fd3b5d58e97c78951e7d783fdb58a8fbea6e7ee22b1870fbaeb36a9f5a76c3d89350d548287cc8d5552
+c: 9ff5b15c316ee793125ea9c5eb2990b0107f35e38df210a42cea4fadfd617c9110fc0d3d982b205e7142c8e0bf577acd94adbfbcbfe22e90e40bdebe81438355996f3abe0f538ff8cbfc06bc2fe1fa18d60395baf5f74a20db8ce44025fde2e91d6f22736f871b45305e2faf9eac6f04fb15286c84ab47e658f52ff2094f7d3070fb1dd1af78eeaa022204683f7d37b8a0a1ae0d22c5a24e69e218b3efc840ca785e457b2ab6364a19f40072278d26c93859ead52e03565d672cabf7e83bc189ac8371e610d563846562ba0f33c530e0ce8999083801855422e005d590db44a1c1e4b73548e6c90226a00e351ab9deb615a1ca6a4963cb5e413c301ecac407fe
+d: 6a7abdf10b5725c2d894100f04234a413bf7380355462832b0bac0fd06a2d3ea9ed2b762f9cb9f632d48b1e036270a54869bde076531829a407be1623e2c294dcf7f65b65bf59cc4901b2b062262fea374cac1184ba55477651c56a4efa75fec607bb3fe0e9c5374eced6f96f13b65008347e8d05b6d2c4b6965fcfb5713a472191c1b7df6837ccdf5f08c8a1210215f4a4042f790d86cb874fab8874cd8267be43377e8aa4e7d5cbeb07846e18895e887d69a4fa4de87ed812991286d5a23152dae080df738762e1e1fcc4dd2e38ffdc3580fec8dd69a9fc7cdf6dfd5af87df6b8af9a50c5143983ce0f3438df14bf82f4276a0f2a47322fea657095e3dfe29
+e: 0
+h: 100
+k: 20
+l: 
+m: 02401e1d7566b6b15b4e5e3ac6f284ce47ddd625bdd9a86f605385ed64d8944480933554becb2ca07da470c7719b0e5d95bc82de77b4cdd737f9fa367d
+n: a2d41dc51933e5a8502e05c3c71fa199aa73cc9ed9e18861f7f1d14c8bd8e6d7c92c2fa75090f1cb4e9d523777fe85807979f9450477ae4e978866964c8255df6d162ca1a61ff019985639e3bb06c6207acd2c0c3ce3df4535f19a4e2839f68039f745118600a5411b1a6f67c18e7bd9d80a71261aff2b04820f69dc9a2d99062a18ebd85325386937e1bd5d3a3281220954ae0243c646970b62f4bb23666f828d889cbda4c96b86143ccd5dc73a2bb9a9efd8679e80bba495360fb83a73502a930921fef2134e559d5a74838c311348f7797a3cd10e0dea12fd9c311d3f5bf7c4a868ac1bdc275231c281075faf9ae4183f8bd8e502a25492b716605ca5be8f
+u: 1927c108559726877bfd8603a1570d5c341d491cdf2c4c697dcb2c016aa326ac3a49e18a336099f5e0d2eaeae7734f2fdd0aa9cc4166785ba9a862d71df064b20b266589ea4a4ff04989bfc35f6f9e47aec0f304924f31d5b16b9e2a9752766a1dc1207032ebaeabfb93dc6a8282d3e99e94088417770072e6765846c88617def40ee3e216f44c00c669fd095cecf10d4f131b27f993a9c63b0707701c3b006be85bcab22ac1ca8629a126531faebda6d9b043eb75ff671c2bebdc6de8b36605df525ffbcf004cc3ddcf39b3e6e67b4800ee52e39b02dc0d3ba48e3c4a1a99eab48669a80afce6ecf63b616f9fbba9ee7d742b22a80bc1e6cc0268924af0dc3c7
+c: 52d9c9e28475b8d51e7c44127dfe64205f838a9edbb4d89e20e3488ee46d9001ddada832d4d1fcbebee03c330d6e9ede90fcf51bd0fa06ada38eee4b71af0302182d43894f03d271be0c9d1fd108fabc636a8e9d69ce1e96bf30fbb291877a38f4167f21132cebd04f30d578a2329515cc99ade48e94fd072fab39890d10cc2a45cc7a94832a880fe8b0632941e088317f4e49371ccf49d7bf97c498747c2dae57b024b60fadced58cd740f9822c8c3d9eee2dfb233c08c42562fa0ddb3e2c1126e56677fd0c4afb22c77336f3085620f368f20d58ba596f7fa896fd4062f2c3adf96808e8105ec4fcab6701ccaa2b26c4c759bb0dba22a1804f1ecc74abe26f
+d: 8da34443aa8867b6bf62bea13f601ed799c699bfe63991f6209ea1465bd7bc6767bc7554dc7c364f137bc8f7c02ceca8a0e828bfd4409b2dd49ed121f6a8d6d0d7422361da5be72b73714579f00af506aeeec8ddf1fec56321734ac769eaa22e8afe80d84fd6536710ee27ebbeacfd05f32598c98495272cff99aaf949701240fb38bcf38c45f1139be40408635df7ab2e81fdd17e558e04ba1880f895669e3189d5bc5f96ae9f0a01b44951cffa90ee613fcf19d575b8b372dee7d22bfbcbb7c05a345cb90ba8db2a52f7496b6cb010c7dd3e3cd9b7aed0151aadc820876368f61faa67b21afbc016999a4cdd9c49e61696d85bce1e0980632c63221db6d1a1
+e: 0
+h: e0
+k: 20
+l: 
+m: 65bc62016aafeb92c6944681a31d0447e5bbc62e71a05725e379b7a1048580958376892f2e129ce14916edceca45cdb612
+n: ce07e5c3f7c0028a6ecf10ebd13ba3e7466fa37cc44a2fa8d437e07b4306b7b533b7a9754cb3e333004712eb2d100a1f76ff96c49af6c1fa1cbb7339b7a05854e6e40c40205a31cb433344d3feccec9c58fd540abe7791ea3e0fdd9ad150fe278228d1af3470119f50d70f517bf9bf7db8f2e592c691c71f92f12f3649f15c7ba64b33ef0bf20d0a493ca9dbae8f69faadb57d4ed8a3c3c7d5e11be47060cdd25ae132f2e8388ea7028c7c3f516b10fa32ac699d51d120ed1e405b192233238efceda03447a312b90d2811e904eb31c5d9d4289de378dfaa74a6a7eb32f0e59fdc668dbd54b236692db84df6930001997a32cddad68afc1812131891a27c786b
+u: 13e1699f62722e48332ec6d4a32afed7298790dd9d1f6a8e9bac15201f53e926ef5dc8dd4d87251a12f96b50f1ee4c51d752a279f68ddbbc6bc12e6b76b8b13c1beff6c567b6552e8e6ecfd64f004b9f7c2b6d8150f6941d76bc323b37210ab42cbf677820d4de65356488a5444edca7dabdb34f4d7e11845098e446868ce64a68d63df93e3efe2110f3087600499220c7a0c20ff7ab518ee33ccefea815959ba72eed1828d56f4cda0194ec47500a99213833a92866f4c108649598983edc7e4ff945bdc025ffcc4aa93787cc24115a187999ecd3f6e8a0aa5ae1c7424d77af9e9767172e577adacfd447ab6837789e687c693e06d22aa9e7a07c1bd87818633
+c: b5c5a780625158063745487f0b82b16498f4b58c04d72864a7f271ed72e15fd4fa71191ef84ea270b71186165b8d856bc02635e7d7f195f845d4432bcbffc477ddf767e8663ff624875475b8b59b24d6a4eec1f40df2851e8d1c4c1f3aae6d4d11dbfcda6729b8a190ae2d226aceaafb5c1d0ebe25bde742107e0e5dae73d7bb7a706206a56148ca27f03d34779e0505bf265568f3195582b8b89df4136b15dff766005c70b087a86030689a63ef11f714bd21f428d9e1a49931671cdccfd8d43cf74f03d39426b42f9a924c2db8ef94f12c2da762ff59fa015e917780a45e593e69b3e6f87a679f098a3903f68f4451e185841c6356ee9ecbf3035d1520740b
+d: 21fdb1f214b603f5aa5ff1eed4aaeffe3dc033e263aaccb41b451ddd0b046cfd06b6340504d47c45012d96229538783ec1d328042465c1d3d8c2f03d38463fc252e0d9bb1c7ae59a11c671564d118645557672dd2af267f5dfa578f80f55f56ff8a1c17623c4aef841bc59e2aa37e4a45fbbd636215f66be9c788290c1437df48604b61f99c071be17b87549c0ff0af8166188eca66067709b7eb3f6a3236262b9975d70f61ef3d99c302b78b25c92522fb671b0d0a3001fa05c55c16c987226e9a4dd50003243f44ce939126214c59ff94bb53c38f01e25b8198c2aa73a15f0a040b5be497847d170afd3d05860db1335ff302c789f13e7c130c429bfcb0861
+e: 1
+h: 200
+k: 20
+l: 2570712b3677384d32
+m: d40ab11bea408bfe989a221123e10619576d4952cb146b8500c35df08d9a18c85c2c80da0977e18da7a16af6b796c936198f227382f867973541ab1e25ed1156ad301ad9a7b6f292cb607b26ddd1a9d2016164754a
+n: bb8bb39d008ffc1d1a5f2ea7fe2438ec82d53b694bacbab4f42c29f1cb5b8306eef4fb1cc4ef83b7b380650aa20dd33d8e2878d9dc6fb08c93e8ead6c27a5519f67fc6ab6ec79edcc5162e0d5401f7f537d0efbdbe6299b7d57c06abd29c66b7abe57e145f3c8901f47603574a27074a5d32848bfee98b7cdba4c4ee31a983c758e580d5bb51d6587ed77bc6a1eb26aa1ec5be13d01ef22826244cb2c6e70c4b41c226fa9f4b1759ffa0bae1659e36b7db31c660beb74e7f0b50af1df5c063521980c6d5d0a78496ebbb1cdfafab50acbbcfcb395aa4d9df45a8e5c237a91fdc7be2486040364bcaa79b4d4bb94b2735ae7a4fce32a71ac62eed18329d3d169b
+u: 15d70ad60e0ebd474cbc7064bdae7a36a6e42632f2064c3fedd3615c51362dd2acb8d9c29a5a661e705846d836b87d74d0f74dd3a817d40a179298dec29546128acad29b85fd4a13c53ed57bb3aa24e4710a43c8431fd6bd6c32bac08e0628a626dd875a64a48eb21d52f9bc3ae5cdbba838f3c91877187ea2acc2c41bf1ec6a71bbff0fa02d772e28115af95c3ac649ec10eb1c519d896ef9284c28fd0e79e3baa58d4a0ca1100befd38116f363a73549f35229020cd88f961e6ef1469a78e189da9f986b1b4c29b7aeb1112fec6b7b70219cb44e1516bdb08e2e8091621975219a2458c54cb2b5b344ebcd12826af6344ce5efc3aaac7aeacd5ae0848961e51
+c: 0d9177d390d0f3825740fff445de7172688f9fabb7514345eabe1c9460357499792d86a16f112178f29f1afa97a5a2ccc04afda468d1ab8253a837106bd4959daffb6602df70ebf28909c2045eba63700f40398f3adfb51534ba72ecc0f4575d15bda9c197aa33a7bedcb529f2df367fa398aa31c078e8c33f7d460cd9a97e4bc9c1543be1cdf8cadea7b403f770afe927e2367372a0432a0675d60913978a9fcee22a3bd7085e7447a03d9939a5b90f541f7f6072044bc847577c1dec8493c2a6c0dcb3d3e78cdc8a1990e50f90503706896ac8ad5a0c83c4b508029661e550e016de461ee3bfd7f3797335a053bd51810f194e5fcf522dbc43f4418ec29cb2
+d: 19a9a7b07e614f31ff5ecd56b744b0115fbfc0bb85342e0f83de00459ca79ddf4d5f9109bbf4d811399c8129793a4036093d2b8af024195aa7f651dc345f28f34bf926739110fd32d23bab4d27b1b2d45b3a97f3d80cacc0122fee5411f78cb62790a689121fce963856c9c6725ab248f6792c5254509a21bf2cb8c1f5de8c45a335c5857179e7c5b08daa6313d29747f18bb50c484273b1d78d6c10ca684727b89e505e12c48dd909b31b3b924c316149a5d676841791365e84178aecf6d2e83956132fe0f14fad5330610dc12118a933c3f0f5edc7768243b4305c23e860be2b939c4ad4c787ccef21ecbee6eb49e6afbedb01cc297b68f34f40646d2aa3f1
+e: 1
+h: e0
+k: 20
+l: 62742d223f4457666c7830326d6f30336b2f76527e795b706c2669623f286a377e2b6037525c7b47374f55402d704528233726432a4a6046682e5d427b415e263a3522674c3e506071693a406b5b537776427866225b773d362d69455f296c3a7c76666f3a2b59414844
+m: adf6ce8fc0cd1ac8ce26ffbb24c2904e5b39683328aa1033fe7b01e2c9
+n: c6bb0acdb28e47ab80214bb3106847925ef4da41d2128d035b016d097efe5a2bb7bafbc63181608715704753c5abc4d74c4b86a49b73cf334ffa7d3f80162eb8011a3d2f914de6674105479087f75d5220f0a38a82fec8b2515ee86014add5476d50ad8fea7d31755d787c8b269a3af9d2635ce16feba01ec5d84016b4b98dbb063f601e5cdcd6a97237cb2b0a5124cdf6e91a53de16d1ebd8cc4512915355bf1fa97086d4d774b5777ce8f28a6bfda8d2439005163a68bec1fa0d287628719dab8e0448991c1d746ba1f2fd3f8169d8c1debbfcbafb715db8bbe21b1bd6ea277702a3fbbb9972f56fb974c33b1f5d4d30aa6122b5ce46c8814f30960c8d6b5f
+u: 149c5e43d822a7e7ccfc47b8e7b1a3429ae9aadedf05993519da9ea7c81af1f30554e7dd5c66b8c49abdab5ffc8090918424d85f438c2bc1dada0e8185f982e3d84518c50b0bfde89e9d72bae70245ad7bce960fa5039e6e9b3e39f4c3686983f8cee0d2b0f484c5b9ea0231112c506e6f385067e01bdf6c3083d4f44f31a3e66dc4bbc6aa724dfbd9edd129666d58325d126e2d68254def0758512ba3f17b0a6b6330f3e972bb28f06e041b3dcdb730f8442fbebf3cf1efac92dc4fc1bab18e1fb4c8dc2cac254107cc7ee1d4fcf6acc10a1aefdd9efeb8aba64bdae3c9864cbc87b9690c6c231d2650857a514099ae99df4d4ee5f81eb0e85ffe78ea645dd30
+c: 1322240229d15e54329f6e5173b55c662f2c1b6f288959640254f08cd7a6253065f3fa611b83a68635475ca7c460ea8003be652018752b25612e32aa69eb0ef572f5f20d84bf4d97d5a2f4487fd45400ebc40259139ddf956ff831c25cda500fd87bbf1925cb976fee8e52813f97ae9c498818dd6633e32805105b0839f9b87b25adb8ac56a036484534a1117e7a37a1b5b482ca9cf443391cbfa2cb42d740294980ff7cb66ec4d6398f7e95a0e4bc879d2a2b3711bcfeeb81d72a3013fc1a2aad1a38967b9b0739709b98b5ab63fdb7b11948858234be822e9a9029b854757256b5f385f913758150c914f6aa03b38b4d1fee0e6933b9859f51e2af2c252ea2
+d: ad3f4c1c71e6ccbe14e31f7f2fff80e1a95ef9e2a8dd9e8bf1a3ce50345bf02b5aa595717ab4e07ad53a7f9686cc3400fadab2696500b698c7548677b5d73f99c715d558873d4b2b068e767114035ac4adc546457c0f345f8df59814fb23af11b7dc93205898d07fdad974388c9e9f22b6268b4d98568b20236f699288e349e586657324389bdf5238cb37614ba4e98053b896559b2f12102956847aaef04c004e46f13b983f8ee7bfea6193fb9fd2a69d285245b4b1623be296d3bfffeb5a78e477fc492e2df6a24a47f62a77f7a00509dd1890a9b849fc44bc3722a88207597d9e05af1f98b3136e01512a2ce4c0b8b6cbe4bf0b9699c0ca80715239607801
+e: 0
+h: 180
+k: 20
+l: 
+m: 7bc5282f2cf7763fadb26dcd6e0bfaea685b6e92dadbbe3c7175a36ab10ec325f7667e05e228af2bc86605a7374dadade635e85f9e747b8ae003e75e63f66daed0ed018e0039c0a39ea2b31eee53bb10a2d1f056dd543e1a6d
+n: c22755806064033e460bdb2b24a0300da201f9b4166a1317d094c457b3fd13fe5dc9ffae434468b5c80f800a1d26264cd47c4f95a3dec8023b73fa734579e52dc41cfb3ae3ba9990fe1494346fbc1ff9503d9571d3af3e9c7b5d64228b597cb25ad5f4145cfc0c27b162793ff37e79bcb6b521eb00edbc04f773f9909352616705c20348b67fb0a3376f7f07f0b4492590d579f716f0a4801d86fa1ed19f0c3d4218230440e9dffc8c279c34d7a823d51188e44ea33350f0cf72ed1fc5f989e27442adce99f49c0b3ea5089f0a41f5d2e0f414a63f0b80c42eede48909a6872667dee0ab98e4e0eead52e6ba801820e7ddce9ff5202e55014d682174309a41e5
+u: 1518c0e6aed42f84c4e32523e5b40059c0f6970e01c917cef85893e0c8aba7366c6507267c92a3c1c706ff7fa7ce4ca3ba7a2fb8b34b7e565074e5d8266ac6ecd870bb1a11ff03959b9f419008830fe60a9f029fffb80aa30d4ede48f3fedb68088af3c322c9b7560119a2bac81f2a42249483a12b056d41674165bddd66715e842a92e66ad121546b2766b5c2d1f4362d14b931e3f3dcf6e7c0653cfe8939f2347a58a1466680bd543baa57bc579b28e78eefb3d6b5dc5602cd5c894b62456674566299b95e8ce5ced3b97f6c1f77bb732af6553fb3663201320d8623064d02451908aa9c81a1da4051f9bb059ed6511e8d8c38efcfad42fad69fa0c58763d12
+c: 9bf8981a508044f77b499e0ccfcf4426529505a972e463b9d1f955023131ea184be29d8db0bf78c345602cb861421e447a098c1ca1aaac5d2431a02a33133da3b2869fbf4c0e515250a4a89eb345cfbd63503640e8fc8359469097de59070609c0b4b7d57e3946d89dbf8f209d5f975692588ddb9f8ce28a05b00ec8a2f6679d3e5f0924ae51bf348a2ee5b8abc7516be6f14c236954517413fbc7e21104e1471a5733ec51be6d589649bc77e1416c4d397af6cbf3a2ae3d26503265ddf038c6755764ed3ca21d01858cd787ed240976431a4626bba29a56fcf55863151976867ab5cd1d826f1e1312b9b6333f70af28b9b42d232dd5a57435401e47e71a2df4
+d: a98d7b743103bd6fc2563e2b2ed187ec910137545f48e6a194d34f1c753b76de0ced8d3f13a7ae929cf1df9874421e2639f801534f99e18ad7aaa54df2a9dd9f01913aace0f10a23c0cb85c97d40618e231cedad8147f435fb33f443e6b31f7a181efe28a02d626ee5649c704468ff0484a01e524a83b185a67bb4ee227ab52468ea1a1d3379cf1a028e67595fbde57f40836c5af865d0dc9da4ffb303dca8d0f6f5f41ed0c5003a76fa598e76c14a1068e2a7c5015a45ac8ad386e719afc7658ce84cc2f54d705191925d3bf597889a4eaa208b1d0b08d2f6201d6aa0b6921a755a1c64c3061b9de78ac765e5c517924325ec43379b1be86376e1cac1464c5
+e: 0
+h: e0
+k: 20
+l: 
+m: 91cb304d9789dc44c1578d383b74bd6d85
+n: b8a86b47dd1d88d45e3af2bba5dd84ca66b42407fdf2468fdfd33a8960b05852c91e898c8fec2248105aec3c87287129b108e591f0896ea10484097f74905f0f2cecdb70a1dabf159fae9eaf7d5a74ba8600c089b1f34b7a3eefa96255dcc47f62bc5e3cb56c93f63b4d20b162df6915ba9764bfd9b428102a7ac5fb10088a73828793322ed7a29d64bc9c28c15f416244205ed29eab9bc2d2b8c6a0638c6f26fd4d29fe28db166d71174dd6754119efc8b73c0216144167f3d82196dcd2e5d9d393ad916c110f6e3bdb43043bcf4e51504b79c2c6e724792f2e867dccdb1535bcb7633c9502cb82837e93d265cdf30d669c973ffcae7a47ae7712d6583c1161
+u: 162e7ab76499e43a008c0092f4ca8c579fe963e880ce37bc9ef1f7eee4afcde89733a5ded9968afe1832e681870862238e6461ee8d4f593b44b27045a830bfacb9ee20dc19d276ba0c6a56fd5f602cf73f309be76d313ee5fa380ea24b3e2d8924f104f3ef4eada48c680c39cd35846875ff164aaf4e6f711e3b3ec48c570758542a7271c1e5caf02afe1dc0f0183f6fb403748ac075985a0053a93f5356b1a83e5115ade080e8c6f2fc592bdfd71994305cbfb05ca851c2c00a565e3c4e4b70b6224f7e564f261be6955d7039907f0e221941e6d007f4a38a480ad98d4322e08b451a861324fc685d50fa706c664c2cda616df5d202943612345d55ee0c2761f
+c: b234e8be8cc95bc0e1c7fff6dd367181f1b5e3322f67be6a62a26e53f8e8a07e62db8fa146773b92e77afdbe3f4791ba5b0f7fa123526e057b0296d6618f0b464cad2359c3b2ab59bc9a2a01bd2bbf80310f83909cb0cc6064e5abf7f75e8fc47c06c9ab1752872f2caf9741677a282abefc76e0440728a6f6d2cd44578399af93f342af58a19ce125c86e538c25faf118fd1eb03380f93819066f5a730ebf23d77e2d1e9e12a3f98dba4c0a22cc3a66de95f35744296f2cebd2cfae17898f39dffbd50ad8980ea51e6caee2c834297d69c88e5f577d32cea9aaf1b19774b74d4d145c29238b1da9c5259d902eca5267beb8c6d56b24fb05bffb2e14ef0206e4
+d: 82c6862caad73a5be35e13cfa74924923de53fd78017de33a112aa2540349e9b9c5090fa275ea762eb38d6fbe87413b06eaa3a897248f100c9d36d1e549bb14a808e0eac9913c27ec5cc78b0731b377fea4f52915a14157ec8a29b49e8f97c7cca4e3568f13da8df7f6358418cfa816ee6dbce43aebd057b1d3548da1b799b5bbf60ec477faf585c63db61745ae474aa1d39dee505af17dff8e7ae855c83a29ab7bf96fd1660989edd992298c3e6470ca62eabc05fabd938b2feb0ed72625b8c2458ca89ccecba0726cf9583fbf6bef8863975469eeab38c8edb53be8651e270f4889eb530003eb2fffc937cf01e3d87d118083987541f500585a37112bf3181
+e: 0
+h: e0
+k: 20
+l: 
+m: f27e95e2a20308e1963b33f07394ad39436c5fa24e417f1f62902d
+n: b96d604b98b7284703b759df9dc58b7405120f5899cae5bfefbaaca8fc20b72c93048dea092a531efdebf38da8699110833699c87f22a6b03e3ba51c2f38e89c8dae41c7b71d288d14bfbcfce9f2eea7602c7803a8b83088ba0f84cd5427e2d5d11ac7105ec4d7bf0b6e49cffcb3056b4490fc1d568898284aa9a3068afbf78d18f74285630c60e58ad566d90af02b5660f28dd73bc40260fa55ab0e5ebe5ac75e77a838d62b740d76115deabd8f61438c7dbae43ac3e2a259250d2ffd83acd23b9b66c92a3b63c9cae0b4bf7a798db2a2cd82c33e34ecb347a19b48f4611136171c1b7ccd45933edb36da02c026a39ba7a1193be37d00e936e56155a888e8eb
+u: 1616eb2669f52c7a6b5992a2a674119b6b447d1d8f35355a8b6a1c2008f4d4038610412432707a651a6f819ad8c890309f02578b0aeebeca7868be3406e47158e2f97dd0d1542338ef1a778e8e487e83aab157d024ac89f84bc18cfed851231f6ea49ed33e65187c49b9a9cc03131fd4ab752a8a5ed8c59108aeace9c50fbe214bb205f414b1f15a7e9cfd3c72fcb270ffecc2bd0a0494fcc698c5a7b7b2e6b4c595caa03e1be0b9e340f7a0f73f5c3c099b4bbac0d17b58fe0a5a39b475dd2821be5257ff2409a39ec7480cfdf9dde4b7d25273776e88560f6f02a889b326805995edd9f5123e7c128ee361edb30cf0c7ef53145882362188e138c19f4493615
+c: 127acf00a564e93cd7dd3989f34bc1bf7b1e6df80bca9e6cb8f211e30c713bf4b7eb6ad5a387e27744d988d59546309ede5d9e2da11cfc359d7121b0da3030cc95a7631ebe54ef8287c8e025ba865c3f2a76499d03dfbc1ca95aacb0eba450c84c1fed2abc6820cd3aa28982b9a21c5f2038cf92d07f99a998e6589380642bccf01b536777604ac6c8d26f6bee960f85eda743c2e34081419d437e171ff11f1e198252ff19980618c2e7d5edd68c2633820fbe67682886bbc86292d784fcf574b0f5b4803de09ab145ac8e5e222da450128cfdb09931d27421febf4e27946a55e93d7b4a6a8ff5608323535826c6ca2e6247e0ea3d442f91ba72bec728d7681a
+d: ba0a0948c133600d39b0f1113d2415b5d3fa5cdd4cf507e9a36e2dd1c677d0d113bb80530f82f14cc0acf2c9d991449f5796ccda43a6a8ff8b8f7c023e90f50a85ac532924e02ca83158734a5bee893bfcce242553dcd28e2abf1252e3203187072723bf4ff650ecfdb2389dafaa003c9395102dd60dccc34be5c860430309098d346e516df21eccfa9e9e59f6d8ff3b7521add86cf633f525c7cfd64a00bcbc791ae0ba155d8e54c0984adaf6a77b7a9a64bdbf1fffa7e4386922c0b501d8e236cf1a102066aedcd232849e0e62d5c915078edda4078d9b870e98f38d60096d05fbcc0ebbc6d189726dc1f30c0040727aa3b8762335e8a97314eaaa7158c79
+e: 1
+h: 200
+k: 20
+l: 33574c4f36
+m: b8752c5c93257f3a8d64997d557f34425036664aa606a4914730b82b10b2f8195e43e6987a921c34daca2059a23601ff7b7f9e9b12493e3f1b690211bdbdc9f41c2fed6934ba37259bb8a6e35d1de2df6cf1ea057685249c559744efc36ebf0670fc7fe2a6aae98673f2d3a300417d339a80848147
+n: cb9669d1665ea9c1df06ae242c461dcb3db1481ed1c6804d5586bdffd02a3afe7245b60f4050fb7c1365a6172b8bdbd26ee4baca1b7f9c08b4a01339e824e14588d164902426ec4511da8a2b274bdf1433bfd9a546630ffb9c7974b0698bae5e3752bc3fb0e44dd8cddd13d57e7e75f0a0aa5166d2c5cef74854e5489d75360620d5cea01a2a6ec08d345b4310427c5d3dab4b702b8a81a18d697436597d9405b0c72871a28dd04825cd7a1b966661699ff56fe9aa3f67d6a391de427f4e52bcaa1faf0ffa23cd290d2b46040a5ebd61449a49eb72a6034487981b92dc8b249b4965c2ed845a2175fbc71480fb50dd2077b73a364ea749d60d464f84c5e7585f
+u: 141e7de0d37af9a5c950ecee3eb94be1e5868daff7431c4d7db81061221864ec363356b8b0de6ecebfac0c5f3be81c6b17178f00270f375446185f3a690136188a34392ca4c5ae44b5806d2d2bbc10d7be495cbbf983c483aa3543013e94394f11e0ea066245b7990747cd9c94f4a711005d238a9fcfaf56f5bb30b934653e53f940a7f502b0f7f4363b5a4be2d875d87b9af538bc632b0be9c317e2442f62e5e01cfe7aaa483b5d9f4b54c387dd1464473f99dfda781113ff783ec11b900b30e66e9c17bb69a98a0d6d5cd286a607221c633ece6c39de9901bee355f22fb154d1aaeec6e72d022c1df84d95fc197e1f9057d2cad587ffe6e1a7ef1c97501c689
+c: a0f7650486954168e538b726ec016190f6f5a62d7dab23f136350590520e1645a7588ce0d65eb740c9d34549654c7c319642c6a1fa2f1ac0a0122832ac72354ad181644250e4971ac5c160abfd2d4c3ad75a7deec602d529c623bac059627f46bfc2b7e89eadb43921b26f1200e2032540d3985b6156be32123b5e842cce3b206168de43e8be042180f0733d4150a679b39861be9f7f451e4ecf9d762222d4f0e93143e1b964f3d7396317f0a7101cd5b010915e01876c6e0002fa0f5afd2df220810431abc41f38bc8844e1e4f9fc6451ca3d88d6667b83d9a3c2ba250c2d85d4fd3c2242c885dc4cd3a89da0f2f9403cf8b34a3eac410c4ad78c0b3cb07ce4
+d: 64721efc3c4a55e601f8a33705e5a49159adfae3ccce6128a9c1e6a737865738ab35ebfd30fa7093b1b7e179bedf765dc8763196476f86e0c9022eabf486f433e4a6c1dafa955190abf9e9a07fa3696942907cf72c8ca12433f2b77d51e7f7d66adb09b5bd1b46b0678674464ac8014bd5b0962d664e0e08c16ffc8089d646c8663babc8a28d1b818ed5bf3d8f46f3c468be007d41eabac04a46fdc8b6d9939a2ec5dac9bf2d3f88d0e006f1d2b8b3092b90baf0e4fc297799aedb573903ca23939ed8e089f0639ea43df90e39c15380f86db3ff14b39af24c8d46ab5fc5649871a19c4aa974f88bcaeafe49bd2abb7a90018f79513fa356dcfcd7425867945
+e: 0
+h: 200
+k: 20
+l: 
+m: 12bc4084f1106e85d8df49e0e632ffd942a5749b3cc3ccfb92b1886105b308fab5b2ef5c8d3101497f311ae1adea392e94f99b2c5327c0d9a8fe9b2f236e1b0e15
+n: a481d030141abaceb699925f0c28ce4c5940b85c2c217559397db315960af1c4087c9df5bea431a1d8276dbd439daa9d6bb508fc2b072783393cd9b4af27ab36b764a91bb76de8b3513d0ab6422622adad75671fe5006508a176e97b32b399a16ffd7861147a721a4b7b85402c4f820543d756469af149bdf99b7860aae18040f1ce03375227a689acc89543d375324d060abd9d135790e7bb33788546bc6d79f0aede01392b080a9c32629b0ade7a899d360f1031357915ba9fbeaa8b6f74d72355ed5ecce6804352d866dc4b0f533f7e9ae05c4fe7a0c605772a4ee47ef3e8ab2c12e39daefe3a0f04bef2154ddc48449e8937d826fba914c8c75defd1fcb9
+u: 18e60c389694bab4f691bd429d983eea93691a1831ee7ba94df23df9427cd989698889e7ce91309efe80a15c365f4b37567c02417f8f5049999f135f92d7e2395ed8330503dab3d480b16231170c96ce403ba9450a2b2c7da9d2d1de69bf81f0914601b011a986195223f30ea6ee9ec7b55d186b753c46bca71036cfa5dc8e51322d7ea670fae71365a83544a56a310622dd34c8bb6c4e04a576ac0fb7cbc44a5f7232a5152a55b129bf4340567ce94b569202737c1a6896996a5b7c08233bbe5705f409142de3a0690aca4bab0417da781036bd048f69d34347cbf89271894b4a50bd01698d3d1b9149baa90d90134050a28a0c2eeb4a51d93b618e808c1b582
+c: 5a83b63167d3a00274940c03c729583c11f3346746773528538edbda4f0687a116e427a1611c9c760c126798f6c4cf136991421b2ef4f5712d257accb9e728899b5d63c28f37a0cdd225b33711e6f57ca68a33014a59b6f3f2dd2fac5a3b976bd088b73d6808ccd3af6ef4683ba7655ebe18fd8d8623e26557dbd15e48790dcaab4731a83063bacab96003be0b9b36d30abb4c40d0d11c48f55bff4c316f509b13b6a6ae5459c80bab45393c4a31645e40976876770a9823593eb02c54075b29965b5104a3351ca64f1fcd2beb54f1a55638d5f12cd27e882f688904c2cccc45f6360426ed4dce0596f6b5321e8a0b1e98b85ff34254ec00b640337211249999
+d: 817ecbb26e20a62917f368e43fbe5673407fcaf656ecd6d5debdf7b285a19e4b1ea736e65c3e69293f95e3df7ab80d211d88bc402c3f4160f4892ac0fd73d2027d2e66229d2247a7b6412241b0dd5b23444ba1a607b99247e4c832322fdd3e05ef94178f71a0d501d1db3dd0d3acd68038d6ea0ef6a42baf6247d75dd8d86050d6b6a771051715306a76cf1c21795f2275acd7abe8389c870acccc7a03cbd5807c59eb02e0d3873b262e88ae00dd1733ae20261fdc1caeebd829eca0700185cd9573db6ff63252721866997dc3552118ce27674d9f2bb0f766b8a3a47b9fcceae8661520f9b2d88fb8b5da5b46bac9a1438f83281c5227385cea67bc9bad7641
+e: 0
+h: 200
+k: 20
+l: 
+m: 7c29b8189391e5246ca1714871fed7797ffc1accc3aaa72d10f70006aac2be20c7c8732fbd855767
+n: d668addb4d417e1dc3b9b09a0940a01891edae28f707d65084ca9b40489135b2dc5a52cb981574a25dfb3c81b46dffee102e51c8336d32412766bd4ea8fd86a19b581f77030509714fc0350030375630eacac8ca5de18307a37cfc681058ab7d3c5b0edc08f3f2d2c2234f972ed959d0d5873ae7eea2a972a83ad6fe552df75934c2a20960f2cee02bbd9c7c96eadb2b062c5a9d89cc26cd8d3945c07d80cdeef109547d585c23b2419779a180e625b1e84dbe986301b90acb5e258a6ee3b96e1256e9842bc9dffe38346b96546a30c4d17dc4f1a6db931f8f12f802b4dd826511d8b759933132eb4a4d0dc615ca272c9d10fb461af98d718c6c4e0f8120514d
+u: 131a8b0e99de421ab7620c716a6ddf163b7099d76ca2c783d1710ed0a0f7d8e44612abfb9ab2845befca70c53c166e68d9d0019772b16e455b5d23ab2a6af4e93ca85d7747f943be9b5779e2e0be7b6b4bd2418f6a1eae8deca45803dc87253b7fece93c952620e2f9720f69df85be093b74e26698b3ab7f82cccf0482783f2ce2363040015877feaba102f0475ca87efa1de8c6598c1474ab78e504225d08e2650624d3f2b595a54aa4ae595232b5f3972e2ba333431773911894650aac9096c028d30f44fd03fd141346af46836af53eead92230fc8206dcba2cef7674fbdad9765567242ec372352efafb445b3ba932b3165abbf5bbb712564119b74be2b3a
+c: 44c2556c21509c1c32cf399e4f6a7bcebf3e80d0af574a54e082b977e7a4b1828de5d1a3ca781ab970cc37a1ac646d9f8d1b3f6e81d421ca9099a6e5d951be0b30bb9b8a671ce285fdbddb165b855f84c3a2c935e08c6e7072f11edeab80093baba677ba1f0232df0eb1ac8dfe096c914b54b5c020df304ffae304cebb2ef1da8472a58b25dc48432c2ea6c512d420ddca5a15dfa630a734d0fe54409c4cc8b52aaae7a6622a5ec8515288539e8b3dbba1553ac3403c83ab87acedd70d16b2172f4f5e3f265e77d7c4de8a473e1f0b59c708e265ecd45cbaafc438b4539041c88f739f759901eabebb6876cd9a62c09df81abe09f3333e0a66419aa376dbc61b
+d: c8960f8abee686b796ff9c24f8b90fbe2527afbaf3f3c4f92fa80593367232db9e913765a92f139a1571edf7180b5e4915ff917a15b4a13fffe2b2e4f94154a071b3f6d2598d5b884d38b35328896f7902bfaa01d5e3c6a78c67602d14e26722c5fe329d1295c349635ec60afd727b23a12933c2b4ab06318dd3885327668f45efa50bc880031391f41347639f99277f3999a779af4fafb54169c962d39300655f8b8e899255739ab33d826eceac7d1865e3f8402abfa6fadbb92e02bb98a8267452d4542f22b7bad2e1eaedda506eee14f8d8e7dcc4e782885470b9fb4375887e8665600840cfa1934299bacae227941d967c401d42ef32528eaa13316cdca9
+e: 1
+h: 100
+k: 20
+l: 672a28734566457839522052486259572968453c6e7b4928237a404f3452332b3a404c4c66582a657651593c6654475e2a4a5434557e30713a535972763f212923264d765040313c427b684b68675c30627e46717d23693355343f7871
+m: a92b46d13052bba4e576bfdc1180e6bc9305da2558423006b61fdc5609c17ab7e68e8ba24a5d91f4e14371efa3168b71b3814f85e2450664f566ed5b308d10f1f4166f3a9f59af5cb44f9c9d368c512da082d7ae380fe50efba3830e4e00f0ffc7f794e3bc6940a3869ae16e33729d60b1024a3848db912c1ed5a1445727f1cb757ed103b11bfb6b00049bf989030c59953e3142a497e0762ac7407629e82355001dc37296fb9386bdc6ca946a01d4d41fdf02
+n: faf5e75a603493093ec1d73968b3f7b51d026b28c96c6e6f6e403435f95c3f35b78e7d844774400c16120f63cbd1273506f8e9395c960cfbc0f2f6ff0877509e240cbf91ab4144c54a06ab34f26d23f3c5fb95efa321cae7059d7033b6247a5c6e8878f1b9bc7ce97bacf6ca99a8f3d75c169550015176b1588d17ee539e400339e1b9cffc0543594574a0662e2736892fd9226ed6083b2bccc88602266f5c7e457e09041445c4df3026124ad842bd80cdfe00db9b52c580a3e3858a1b3be8c7e10644df5b46e10f8e774be882fb1ee9d228138972fe192483754c5bca815f37faf0637590d88775d79e1903dd23aff4da9cf9d59bb2aa4cce4c4577bb7a1a45
+u: 10524008f2490e8f23b06c3092b9f1e9938557e55aa9ca2b010b7dfc414bef07549ce03cf13831875cd909dac80376c0b7d426828353f42b54a761303ef95b38f2caf2dd09950340c32406c806f7d539de325aa6ac74e849ee782054d39bfdc002e6961fa8d4dc13ac4266ebb14f04f7bcf6ac436135ced7d3f4d02166411a8049b546def2cd4968b970f83b6e37f90b480948785f9ef58404c5b71d1c660b6693d35c1a243fb44e2b9ca44803fff837923576cf72875406ce6b730408773037d4c46951ec9896552185caa0246c58c5bfc9752d26e03ffb4b7578438441e2a4dc6b0cbbac2c0dd30e40aa42939871c340b4b7e5ecaaccf95ce8035be63e1da69
+c: 6672576b2a00ac6f08b743d7aa8d28d7ffed4f1ebd5fd02c871eadd8d5b9333006064f4b4ba45779951d4fb89e1715132c11d160058547451e1e03c6dc493b9ad7867b3306194544597af1cc5286f3c9592529198f177894f39d652517ddfa665f4ccef6bb08ba1306cf802b70c06d82026a076c4b7e0dee001a936d55b1e230796ea9be4a6f7b1bd4b2abaeb005232f4f2821fdc919b145f740afce92039d74a55cb8213013ba42dc349e31a982dd069101fc7e0b0d9a14258bbb59a8877a700737039b4c15f7ecc8f26dffb66b8c13ad2e446d3829f32004407a5b197dd5318e27fd7f73a5d1e0ff377229e8a1ad4fba4bd3a469a6ce95409bd80f6684540f
+d: 50e0263f13a1445ebe9643f46844e8bfee78db1e836e0c5401288416e9cf59b622649f30f284f327c398318dec6ebba65e2c4ef6dc52639f6f2950d17bd026ac6c9cd6c468a54bcfba3f030d548f76a95c9927e81b67d7a340171e7be3de059497a15edae24ae9c5b3d6b3a8bfc4d0a8092f06d7ee3b48b00611bf3f84cdc15ec6029d8675bbc2a184003822879c905f354365f24aee3b11d5ae2a20f8c090ee2c4c546717131db0aa31e42be73d7e3f623ec6872b8cd80e3b138f1f26ecf0ff3891f024507f93be8268d9460f630cc427ec26253e288138c118bcc4216f5869ee56bf18a696969eaaa61838b6d9d5a93127ac5b0b69bbeb56b5b6f9ce076731
+e: 1
+h: 180
+k: 20
+l: 6172677e387277343d742c6c70346d7a607a462f2942432f786e7b3a412f4c3b402c6058324b5e31474279744c2578207b6f565f327978776f6b5062246e633043525a784b3d2356657d7d2635
+m: fd7ee7271ec976c0119ab3fa2eaa2abfc6f94229f7bd19ddc850e5ca2c6a1239a7326431482171
+n: b7cc14174f742aae7b02d87303c202c6f2c7adf823c322cc8b179b4ad0e1ddda932314335c5b7324afe8e4df54f5dced5b3a5548d6fb14e0a71c51692a25454ce34454bc1eb1d4e6ca119fb4143624d471273036dad6f61138247d83b47456e0a388f61cf324e05975f21c9462c37aac208484cb15754205b4b3a675523b51a0cb8a8eba5f0e5f86a17b7025227fd87accbcf3b5a2e8b5a1e0ed371bff9b50ad324b331786db54e625d87fdf35d39647211b3f5b01d8e6e74659625e56dc634c35bca98aa0cfb6495f88e3e6506275d3daca4e4fb1d55dc700c3af151842694e4353551beb050812d7fd9289589857b8424f8305cb9c26d4375a3a8bc286631b
+u: 164912379995a41c2e9e75705e6eead9d1e7200948929835ed85ebcccc30b8e69f7a4d05f8788f425cb3435928fc282ee7b898aae56a6a0dd363fa66ff8647337a386193900ff81a433c24fa783cc16d299c966a9c2326b6dcdf6e3763ae5854c54c39a2c640bc8c93260d412530d77e5d6bca455ac4ab9eb6a503f2f8ede878ea33a01b66a161bebf715ecaa4da5a9e5506e74fbb8975275802ab21800da0ae10ce50fc37a266a33977655347b5d7a4076b75209ad4f5792815d0559726d105e9f3016f65da4d8b0b260361171a12e9a015799a0e785403d25ecdfa6d6863b639bcdd64b7c33ea9351d4703bdf488af9e90141f4e4570e475c1fdf4922b7b0e3
+c: 72e0220d044371c1543bab92d80cd0bccc9eccaa72736d0fb064f8d851c69fc95a1d2269a87e6a3146f57cb23eff31b77f99954757f35094e6c7073e360cec4d543f1e68bd8d9ed650a951b369120120676e6255924c4cdf9e51a2ffa93de053f322ab3c3def0d4484f1d5a81824a857f341d31d6529d0d2a9e6e0929f14e4013fcbac3c9ffcda68cd00a3caf07350500db5b36fd92562168929b44f26061d8bbe46d4482e6d21f431a95d822f2927a41ad044830ddacf6650cf7e37ec54908b13d1dfa45ba68e8be0abef80cb9667e07be5ce673646377769104617a11d2c850fa487498a66921f4a993a9c9151248e508f1333b775836544282651013dc15a
+d: 9b0ef3277f25808c3e0e3de818bd5f820546b3d2dbe455a39bc10f2ba7c1e3680e8dc3e0d35c85d5a77d30dd50c21f1ce57a9ead9fdc1bb072ae22dbf6a81e8ef806ff20800810163c1effb6d993fa360e9d1ecd958ea2721be058deae6bfcd6fab2e5b9f9d1693cb3049c810ac9bdab4a93aefdd23c8e7546430080ba7f9903c645121bedb03501ae1a80aaf51456bf0a74ca50b2b0df53ec47ed3b33d79444b8637c8a7d3d40472a1bc9fcbc42d159575f2092e14b69d49d4efa23f129f942af87d1bd557d39ce0aa6b5aa8582df258d7dc8502648210a85324bd2184160a058eaa7b4844bb08d441287a27016a4559bdb9ba90bb78c06b63ebe9a62342831
+e: 1
+h: 100
+k: 20
+l: 5b425e36336f635f4d5e5e255f667c57286e74454052287c724f4155477d27303f4f79696d2b49633c237321295c4928555a525340676d24693736405c3c243e586a6e2d784c725d353741363a453f4056434c784b4130507b295f413f58427a524e50294142
+m: d433a5c739a9b40927adcf8cbabccf1e02d9f44d9fd039e82c17dd864417f9709c8bd0fa69355c8ed5cf666d6c0f71594e31bf589a3aca38676fd1afb4c4de8d827bfa4dcb2415554c15240209af588cd7481cf8b35f0a75cfa11ff99ef7537243793d3a
+n: 9dc25e5586d055fa3b5859d7c066fb3157da6c8eed958d682675118e98569e75d3eac98b217af49b494edaa5f249633a87e49414ad139e756e97dc86c3a2c0e5c4b8628f13adbbe204ecccc278de18528a429b13c5f200b5daa4e0bb1a9a284d72ad081d68512e8aea8e691ffc5ad22746397b46501f396c47defe3afb46a3d8611c852af94613ad7e1c555441b43cf9ea2fd3c246542f47393ed7ecfe7fc5134a80eef0b09a67ed6c7e9b808c6b9b1fea18ddd801f7be0613f575dbea0148960506d9d5946563b2569ad1907be6ac8d53c23a9bc0e23df375433b7a1aca7c344f7308a9fe34dae40dc03b936682b54e4300c184e30a59d6e2038b603516f149
+u: 19f6af45fcc768406f81385d6c950f1818888ce229218bdfe3ae4e447974f3df181c57349410a205e0a16a10a0303562b17f147642178eae50c7560879e6b020db1502762234cfd68bb1c2fd274d4d50c386cca66e0ce41c22d643cb09aa9233eb81eea8f924ffd4dd21d4139f1ce4f3b8da468024e6aaa51c9dd8d95e09d41740b9406b7e3c67e1f6f4c90cd13787343f8ac5c42879dc9660ae1b1613906888e994c062ca18376d562cd41d8d4b1246aedc6bc029e69bfb87b64e6d9b38c8274d5c137c07158ec63babeadbc7968a96971ca37a632c1973cee8809fa942d65580fbeaf846597951322adc77fdb9064bc4f2f18b74381df6e9c2eaf9255210a8b
+c: 55afabb07ad067887028dbc097d419b547e5bec2e22b2b5b2e76f2778fe9df6c6f74cd9e3a53a07d212c86e702b24a03f3223599470222bac64fe6f420110e35ca1f0fbca6952247c1f3c0aab791139e9256d653f37de42b2ae470147e974100ec1fdd19c7a336102306daae127e40a58c6f9aa4235fca881c82134d630af46971e69209d239436f69af1571f7794c9ae542cc015a0d7bdb5a75b2d31a30fb9bba9972fe19fcfbfe375c46ad51fbd69421b8711791cfa614c4989c9911f770febf51ccb596972af3f396c69762ee8955b5c3b710efa1119111665545e80ef6cbdaaf28f5e3febd1f77b964afc93da0d88a7dd04dcc92ac93556986ed5f15c339
+d: 72c44e42a7d17062809d5076de0f2cb6b2624e9d1ba5fdd896622104b72e00d2868ae11450372009e10c5264cacb62efd2661a59d66de12e0d7144cb8e306be1f2c2ece6132110193fb7c4cb120b6260eb22c318fe933a3811671c8bfb5ca58b499f45fe6a75ff93898ac8cc01b967cbb6e2509b3727ee89bd42e9d024742d805d179ea0130ade5411c43998d0c845cf59a9c16a2f34c08ebdad86ec8652e9d9b8436d3291ca2d0d5acd5cc4ea68658550a8d80eda502a2dc608e947521c4dd1183ad2a29e48cb503b1a3699cb3e027b55e2aef101f1848d2d82daa2c142defceb2ac7d6dfa7d7476baecf1deafcf097089ccbd438b4530a64b9ce0342f5fab1
+e: 1
+h: 200
+k: 20
+l: 4b605c3d
+m: aa2d19f7620714f6f5e30efaeafb57f21e027798f80d08dcc7c859829c690388d84d0dda5e770460028adea2d87c82b737585dd153ed61f7beeffdc6567b59d9dc700d3a183b38e30bca7abb69fa7d4e07b9e7261472b9e36fecd9b3afc2a7fd
+n: b01f45f9279fc1027cda0fbb07dd70c46be813776f7ad5f23cf1b18fb673bdc6b68735869b90b235b169e520a1095fadd5f44da3db8d49936556a8546b8a6cc10390e267c0a52dd8fca31feb6b850518dcb6f0d52024c96f1f8fddf84d73ce825ce1b9c140a8ac37ec53fc0f74f5ed28fb77e5fe3f894bac19a2e366943bb77a01f14cabbb43df0b55f86b9e7fc03310d8645d579f8ea3e95c624318518312566c8b200cb38d74cfe6fb19d33345995128e7763972f33f197eac18cf2e41d89fb6fe2f60670b0596b7c4f54dfca4ad96f7067614c3372ae289a8583003af35379eb4773d2ba820d8e064407b859989c95fbb3ad75ca7fea0091599bdac7db13f
+u: 1741af8c390a3a12504a69f4017f7ad013c9087fbb8e19f1502a14bd6f5bc5b1af60d649c385fed369f178cfdffc62588cc73f8104c640e566099b3a8ce83117627196c44f7dc39bdb8553e18c3c5d114267df09f5fde747709fcec2a9cab33f27ca49a0bb6602da9ce62504f4bad6079aed70d8d53e2ba905f6a59a32cac9c1cd6aed5cf6e9c67e2abf4485856f491766cfe5b5c0d9e4957bcf17843b9fdc41bdfb8337b8454dbee286af7cd7ccd6dfc1b10a9e53ac539e755097bb9a57dbfe0aff1e348afedb4a039e000a9ae17f8edd31633db6e7c5eff171ec0e1cdb591dc8d67ef2e7db51a86fe09e97d770fa1a9347097abaebd67eea97d00d55d811a2c
+c: 0a4b82e2bef8ab651744acf6727cb28630a058a94af61980a09318c5721008aca8f2661a12913626213f652afdba4ff614666e180a7249857e1aec525a90106f229ee0b2ea83329b4cb529dc01bc9bf2d0691911aeb2e9afe6a54ebe531c62710d0c23bfa7c00a11fab5c104078fc19646b7329bcced85f85686ba847d584771e26ef6f4b70651ddf645e5cbec342cd82cf2872422ca549f6a9e294cb445e8649b49ae7a8ff442b4f9ce88140a0682c35bfd5e45d7f7000091cf9ffae01969ab861eeedac91073c738a07bbc4695c8d778dd6dce2eb40574e94b25c4182848442f3c0c74d11074d7d02c6110b12dc44199ffee6b429060f8c46bab3e16032c42
+d: 8040338068efd39bc5071e83b4fa61511a85eced506529b6e2d61d08c54ab103e43eedb17be205ec92045aa7de834b9b776eb94b90f6a4f650f9735778f358bf020c23108db38fbc1cb3b213f0e359eb4471881fcff46fda3d0e79a6b46186cbd88a7f0632bca11f14336f97c1fe2302f6b439624c0deee7a9d6c0b7268062d0dbfb1ae1ca49eded5a8cc673eb4bffbcac50cff5bc8fca8a96fa54d45d1721776a43c78ef1bc6d9e34d4a8dbeefb5b554533bba12fd067558dca449c9f54a7c93c02d15e82f21b1ddef001e88f54078c807d88ea58c675f4d1616691f4ec473a6c50294fc3e8502ffc82608c6d49a8a5dae1235d38836fdfbfbca92bca46b231
+e: 1
+h: 180
+k: 20
+l: 715d55606377773957604b2b6f6c3e7c495a71496f4a6151264f6b5d50435663704e713d54377c263d355738364e7d44377c3864463e69742a3854744672
+m: 8d3affc433c28a9d8eedd8dfb29d358cd3ca3ac06bab8d24c78a40ac20dbb76b
+n: dbce675b7ff8b1686530b0104e13186988e4e718e13a3cfd4767f2c383e71c6c4d6fd25f16d51b046953e8dd4f1b294e0f962cab51ecc5b04756693be9c3fc81fa16eab56b48ae5427df6005295265c39dac4e64163a6abed1c7129cd15521a675cd883c5f1c67a1ef368a66cd34d24d6a8048fd4fc85f87fb5471c50a7962687a7e903d0be26e80746db2c886372c0732194536c458c990c0da5972d429a28f122e01820ba82fcd68dd5138430c13f720f98f548444e01a5e6755e3312580b50ce712cb28aae35e100d8520614592716de52eedc5fa3c9518fdaa81d65b7c59653ef5f094b806d92917105d7f862e3e7843c105cbe8a8636ca1e84055bc8277
+u: 12a2749a793e1e9b32328051e2df15d24e1a398c18f9d5ab0a712c2982f9abfea523bec989c43c3f80db27178cfbe8d92a6c4de07b62ebf81e413ba3991108c4b001b8cd4f0f957961cef8bee8f11b03c3a342d5d7e9b8cd106c2497aa1cdd8575c2c0af9c03c70b0af39c382e2991243f859e6041a2ffd2aa59107fc75e3c866a9111ac54443ff1dedbd5098353bf92e06c2d8b8e5b8dfb1d5974daf183a2c78e2af91033dc7f911eeb5fc87b1c401ac7866b2d8c79798aea5a7d1511c4d2be16c192e5aef6682256050bca98720192eb68045e4426c2c6bc765cfa4bd4da2bb02d21f1c31ae2a8eb6435d276e2142f73115a927a7012f405dfb0d33113a057e
+c: 623caf67684f7aba6952e4238b38b32578c3da4f5f0437778d157f37025fe505afced0f07da1b91e1c3418c0bc171b83d7dc0e6e3fc60a614fd781fc54fd1c8fb407f4330b958bbdb413d682d49e95f44d2b0ac899f0c3ea29762dc4c52493b999a193b9a2965ea0af0fed88788be0012efb4b489266c8d764e5f2743baf71c70d3aa66c470b1542d78b04ca3d225af0b36a5fbc11c6103d6c5c2d5b009fee670c88ce905f23e88ff998835e4018811dd1450a2e93acabcf359395f1684b54a5a8a96d03ee33e3feaf47731aa3c53de278aa8bda459b42a466cd754221ab82c48655672c4ecb4d06c03f2f2d0271c1576fa95a1a76d165a148f33e6e3601bbd1
+d: 2584fefbdcdf1adf2f30dea9dadd3d41d0979d83e8db9b97c7b42fa1c021e9282ff31b2a73c3ba0411126620de482f5b03205108609650e4bd55c5905f702dee13a3808f4434f1f112c2bfe248912015fd22602f9c61aa9ae0a8e9c938bcc218f5e6c039b13dde6c536c0faf1c68518d1bf5dadf4cbe13bf288ca6860e9f2bdb8df29510f7161553d7875f42f158f1c8345bebe33e00828cf71fab1963f18bec9fd25d6a2b6fcea1b083d00358cfcd98c43237e255019d1f09c5b35e5732c1127bac33e597d2d1596b74e1dfa0b7f4d385d85d9057260a517817f26b45a56aa4570156c0c537ce6ee8a0bce4c22164d75bfdf8cb12925642c870c5d47277a901
+e: 1
+h: e0
+k: 20
+l: 4a5b682b2f48684d34774d253b3328302a4759
+m: e6c4033e62104baba01345095d142d89f1dd25a2009de91974fb31fba278e3277c3b666da6b7327a11f2cf3ed3b57f79fc3257f80e2f
+n: a3aa78846d82fe9b92217f3a81590412c65cef4b14fbfc8376cc5340e1cce75cd97a99b8d341f051fa628ad31753ee0f950c9ca3554fa22180dc55b5ee040b6bb73c0cdc5ddb4cb632807439f1103b8dfe3beedbae81588bc75b825a8e6a3ce4df8d53b481a0d8a46d77bcd9c3e01144a914d61a4d61e1f6aade2d934ee119456126b6807b7c4fd2ea2dfb3282a0a67371124f512cff2e7fa89385d458f4bd9a9bd6df9505150c7088fca98b93ff2714ca74856d941cdbd8fa893e6cd6b6339a9d31cfdc2cd68a02bb1fb72e3d56ac7ea4be01cee5a8b7802317d51c960a0ae295a6d185b94235e71ce7e37e922c50a7b419cf49db7ef0af3b291c18d2523303
+u: 1906ced6653b8ef92dda8a998904d2858b3f96c80311d2147730471bbf9463b4f847c0bf641ad03bb4475587f7b1f3061e515b5f3c92d65c1c96a6d05e9db029fda8b91e775bc67668ab8d942c9a33339be06eee68440343991cd41256655babd00c39ecfa63b786e3bce808049d64778347adbaf4a0917b235e49b8fb5d716b4c167b3137a12dc1cd0e362cdb5f4c318920536df7a5174189465cf0f9e5f00574fd31b8a564f05a15e2e785f953166058e2fe443727488de38fa2bc8698b6a3d6d97ced6049a84d0aeef39f4c8e95042c7f976ac3ad038ad39caa5f52c4f74c66117826a03aa024ffe027348be0f42379b71f24882e2ed21dc84b6a48f11c47f
+c: a129b2ca22aeac6a22d7ae30b192aba402830ba9e7b7bd28c7478c93b2b244002474e6e25fb4bfe3a864f38148767c371c89c3916e03074e8e8e9e4f33b83ffc4e0865f8399073ec450b41d9ea14f42a215068892254d4c45fd999211fb3c234d7a922d5e194f038935f430bac519a9268c3ddca0dc6c6a51e41fed60ce5012db798dd0bf6bc45bfb82983856376879a4e8cc24f317e282bcc5d6eae7eb7c86127d7773cd82cd7b758a1b4f052e6f4c913cbcdf6ba8dfe59f91772f1d782e6694a109ae5523c9791e186f161f39e787445d871cc238eda37ecf2baa87a6e5fcd11242e6a11808c78762fe810ac0d8eb46ac92cf9f19e656c665f1477a099ba43
+d: e00bd3acc791dd8651ff377dbc4f70b6d04be89a366e39f62127475dcc98498a0148242343deacaa193f177b0da3ac551981af385737646f426ee659a1f5ad53f25acb01e0f70d1a5c5320133e84aa598f617a368a44b71278620ad4eb9f187287fc3789b6aa6c872612ed555effcb4b0fc7bb4b5975819fddb3cc8f5a6f1f1f5a7981b3906c222c0dc32cdf83e41703f2e8dc88941abc0c4973dc545542076b8c8f27d7117ad28929d76f05d0e00957b71f3febfb5ab2cb801303360de69edc0d6844572a8bd7bd1791b46aa4a0d228dd92f8ad9dfda7c48808da297076b2f9f176d0b34bd0143a6b9747206b2e465c1ed2c5945f47330989dd6a7d6a1d4dc9
+e: 0
+h: 100
+k: 20
+l: 
+m: 5706a5608957fe8f9379737ea5e644029a92c6e7fd007e5b58937d2c8baba1e79942b633f501ee356b6332f528872a213e05976f35ab6ee2ebd0ad1f50c3c9c5d19c025ddd848b2350bf9de49f73b8fed73a0ecbff1374db
+n: ead201a80e9a1a9cab274062fe31fbf2ac88a56c8fc8c800d4e11366e6396c694701ee1502b7db6b3b085ced4fac42afd25f003ee925608a3e23d15ce94aaa01e1c7e6a2d81ea5f1f8b3cb96f52ab44f76d029e3e68834b1f0dedc131ef9bc854552c13f10ba91ef28dbd8e51eb3ac08ebd3ed92b56f4bf330ec1ed532642de31e660ca5c85de1d61ad034e1a13dfef1a3dbe44954516b4c1f1baa64d8a29fca7c6862252a1326c27879b059b319600afb54e403f05f93dac8e62e7b950abdc7285bc57d9ced8ec36c148423fc296dade9e31f5eb6578b67c628ebaffe1d24f690a1bb13e598338271eb86c04ebe9d6e67d7c29d05c821012e89c0609cbc4df9
+u: 1171707fcdfb9f682b2520128bd676e4669177af81a6ad719d4c0c02531c0145db489271489f0814b7f36205d442e81f108d9886e2ecc860cdeb4110bfd8554519f92b9174b0b7dce8f02ebe320861e81a1a405e676194f411e317121ef4d9fac8294f80143d089d99561c91e7ea4c36a6bd9e189e4d59279aae275faece6263151acdf8fccd51a2e9ba6d98d7b541b8f78cf0f0326b3c82b6601dfd47cfbd7fa657a41a089f63f1f460f8b2b6a58898b9734f600e4077f83c94022127db2e991a5da500abc57915e99f7779ec9997b980a2adc3b60dd54a788e35b8006b7ff0a49af8bda7028e5d18c957d5d6c60036a6caa5568bd259bd609d798e4e6cd8734
+c: 3679741ab4f59ddcdcdaad315d259eb128f3747a089d9e69eee1de9608f46dfd6b8793ffe392a1b1cfb0cfad9d2d1eddcce12e9b8a4b3b7b40f060c28d606b18c03fd7e9da8cd05989975f055f320c609b3b93867e21fdf8c9c53600e8a0449bb594a4f0f5e1b88b746fe95bddc9d2bb23f022ec43b3b0703218014863594277fade4ac1e3f8e50a74377b3b51a1519537468c2a6b5cad86a728a4dee4d5439502e9a7b2740aa1cf4856d0b30ba18c0bd0812aca19720b183e1d3e0498c7bd085ea62c945ee57d79bd64e901a6f5b9033e2374294b5c667036f7f52ca11bdaf3c4153817bd1e90ba40876b512af38d7677d302107a33047b7766e777a8e18e44
+d: 76d255c23682cbd4f9fe054e9d1ddd661c2d83ae8943529fbd870833762817f8d45cb4e5e0c61b6ad06dfa737e749426acb02e608dd5491471abd85737248964fcaf1dfdbf8f7314bfef10c926de42bcd891a37447d36f84138b501a42f4ee609f5272342cda538d4fc5b9fa28318763a1b956cc849efb5edcee6b6228e1734d47752cb7ae2e00d2ddddec2e4eb102358b1586b0c0d4c8170eaaf250c52c809a1211f2e497a756b6ca70947197936f4f1bb137821b1057d0d492554a91738d7d6bed34b3080718012901ddc812ef23f21b035371d4f117ab7fcf1dd01c94459bf50ed2ef981e56377993efb478a447e1238e3e563f5fc00de889385ca11416f1
+e: 1
+h: 100
+k: 20
+l: 4d553a62664f3178226c3636797564725f37464c23587e7c677a3c31726674624d6356432d7671
+m: c3dc72b273ec8ca823015aef7861a50543356d00498e30a5c2a35000d5fe47283544e6f48694ba2c8f22c65f7cf9c5798aa65ba13d941cea97f454820a885a77f1ec1617e5d96a5858b10b02214724f8c33605fd30acea84a1055c5d0908b2bfd187169bfb5cbaa65080ae36be136c565728d52bc94fb0391a4e95292b0b04f39952d36972acb9a432530d9fc5e7f244525f98f418810b4faa6e97dd08f40d1fd17d5630a30440eb94
+n: c2571899b77b067a104c40a2235f1ebae554a6a5736eaa99de8a50f31241a3b9cd41ccd44c627738a46d7f49979b6e5b0f0eba058572d9ebc092da7ddb3ffb277bc089abfbf1c1ccbad55d98fc05bc11803d4ea89befbe1d89308a3d1233f660265a3ed4e51e7a2d6ed701fad37e54712a775f3e5d2bdd96bd5f702db8572b95508f0ef3e7605a318ca1c79b8af590a44b97bd0344beb31697a9fb7edd627857fc271eef3e8967684520d2e22e8ce6cc0dcba6ba28ab6cf8a76fec12138d2ba79d359aa4f6e17fe2265004b577d50a1be11550b147f525aa162cd86cfb8ed9ed41c18f34dcdf97cede2d53ce68ee98f9d9be0905ddce68d053913a55f811b62f
+u: 1513919528b8cf7911483790305d3619213dfd9a97a796b50e71cfd4c4b927e0995725f853027870860768ffb53b73d02af3c1b8cf98ebf4b5ef006730854a70214e101db42d0f4360bb2a0b82572c6bbf2f5777d390421e78ea8810bcc2d4dffe4454a2c4e4964d4fe6febd9c07ccc84c95243b3a2536f440034c16b378be4da20c1caf5a8d37a35f6ce44dffbb65331e8837f2e825f69884b8a01e592b83bd97ba63810aa19886cbddaac8cc66601abc27ba65f3a7fd113b35fefc0c76d5c775f70e32ffe086f47a0cbf6bbd82b0c79b84e4edac1d5c39e820a8ab3fafc735ff651298784263b84072743fe7fd485dad0ae9da2cfcb03496528137f15dd6330
+c: 96fe64fb2a5639493e2131f677da8b80e58f9c8ffb3c44b91f0ce4b860f2104342c3524f2b95093e6dc1f1f6ce85087c95cd0d504a330bc888b8c7a666a6569b47ce7779bda9eac61949cf688d8766e93110b2e8d102588cf5f5aa6d22b1d174a61126e6b836b2e5160410c996415aaac8e7c6d2719f624b86f78e2118d34e9f85acecaa9d6295b633361497e900318edfc184b42ec7dec926e543a27478aa1ed9d5fe61a7722c47a0305b3854443e0f6f0af2566db2b33848a82d6676b470769adcb7201cd2fab0bbe5f46fd8528121d802fa717eaff32c68a34aed31b4f83f99423b1574ed3256e469ef5c8ef91be7a32588ce6fb52bd2bedcbbf795d869cc
+d: 814f1de9c149fece871cb9d570aa00da85a25255243f12a06467e36515ff7d025a055602ab4c96f755083fda80c98d9aae5f746456b3d49ae66bd2413e682455facef74eddd8cab7414e41e042605c59ced76bad3990d6e7b73f5f97708f5010ae22bf9661a6f39e5b53ee689c2b4294575a6a2dc89d10d9bf985c75484b30fb4eb19a5bb2d9ecfd1b717575ef9823d96a9a4d548fbfe8bd2032836551a5fe3a40848b3439551e2b60615ecfad24fe09010a855e835fb419e154df6baba704a09bfcbab894eee65af462aa13961a1cee681f11b604b9a836c3a5d59e4da31b0595c39218855211e11fb03589e17673619150e677c98aeea70e28d25d1f069e59
+e: 0
+h: 200
+k: 20
+l: 
+m: 3870f73cb6bb04a0
+n: d9c80929d4469aa4ea91690ebf0ea5d4011c5c638a6cec8b04314971ffe963877f28be19b4901713ed56ff3c384317cc070a49a438577e42158112d0d3f3773a5e2cc3452b9866ae8fbadd647757d68aa984528747f07a288d76cc6bd06343c4984ee0b2f36fcd31b21bf1e60e9e00389717dbafbb2033189d3869d2e9fbe3ddd1e1f99974c3b9a1a8a065ca8ce7eaf410d505538b0b50508f0aa8002e4492da85dff74ec9ca70fe19fa598244890ec31fe1df0d7fbe8b8736ebd46df7111ac8879dbe99802934720a3abbbf1df9e8a9ed7a2a454e74f3856427f38c29ac87230b8f6c96b86bde4160030ddc5c54ba176bdb3d0f553ea690ca7ed2adc5812ac3
+u: 12cecf58169ec201404d371ea617983a14ace0486cc63c67e06af228d728fe3030f2f76d537eeb2227ca47df5f3ca2932ebbe50e777cc2024f32e387826a376a43812b366bbaa54158a441b74aa76f720a530d70ce4d9f0e0db7755304cc593e56f3e31eb0218f235e15dca1995afdf017abdb061c8f21d6cbb98bf98fd30d7c421725ed6f0bc71269822bb6da63e565c89912615c451ff2bfadfa1cd4c70cc494f8ee9f2e98c1560e65a3522f014571e79a73a7afa84465d4ce50debb22431457ff5fbb175b5507ee42919613ea535557894c62adf034ddda04a2f29b50bd5f391762cfca45043095714ba26267cc0a17907743dcc545a5b09f7a2c67414bd00
+c: 296dd0fa797ccca9bd81d173a4d21b5453903d818ee7fd17f02c31244464cb2a86627147d32d3426e66b5971fc59636e07c96efc02bef25d02c363f040f5f4199c655710bef0c529cef9e8118cce902272ed4313e7d1cf0d88ecc0dd99276708987d771987bf9d72027a06389b1209188798a77a080b9742a482a81ae391efe250d1dc787856da9adea468a5f202e9443a838e61480f08f88c308030cec02aa181d1820c8c4f877a0bef4002a4fae352a000af75066ab0029ec9cc727dc67c814c07b73d629b75bf50a0e64bb4d5dbdc18d09d62fd0e837a5d0547a517c80ade1d7bb2c466ba22b828e061d0b2ab6fb92a36f8aad12d24440d5f5bad7afcd8fa
+d: 776872b302acb9cd351b51d00e28ed2cf6c0f9f01bd4855c4152a42577691cbfa763f96b6fa3341f2d497b8e424ba28dd5f2ca417af878d7922e0a0200b389193e794b2870b722e507bcee0f190c26bac0d7e7777e31d38d47d2ddc2429b071b27f0efc54a27e2a02db74f328435aa4bc6efca44b19fcfe9d3f81a18bc9cc0571e0ceddff582588bf3119f0d4210b638c2db5ab5beacda0cc18e7961d15002771834a257c6d41b794a6406aaab2ea6214e05379a1cf86d0ade18696f6a2bee87bc4872ba3bfb0f19a1209e8b4affcb834d749648d745db603b043172991045dd915aa9949d6115785ff1e287e31c22908d12a90219803a658085b45de59b09e1
+e: 0
+h: e0
+k: 20
+l: 
+m: 3cf1b82b7de67b773d377913e9b5bc97cf1df67dbeb3fb670576dda08f5539ebda6438ad9a8b21933ebcf3958a4141c43a23d0c31669b9d48de44fe81c670acf472406ba96c15dea1eee62325b1743340c80acfaee0bae0790cc7416144da73ea4b93137
+n: c05ee977b3ad36487d1bc87ddc3624155ee2c120821e508e36c47a2f98fca7329f36063d2cbf54d8498e947698e837bd7fa058ef44ae844e0089eb422b54b0b00d0137f1799415b97c028dbe7f23b14e21a58894733efdd45f741411b932f584594932d62033d58f6ec10002f0ffa36037263802cb1ddd1f2ffd787a9472f785e1db3a5f61b0c80ad13b9939927d9498ab99cce9d9c23906e75d5f7d199e0cc6a48f7067122e42ed860b27c629e4e9506b1df39853e1750732db256d5a18d08d8be05f7089fa48ba9679ec5af8b85e19ad1837aef5001af3962d28444de108f4d7f4d03ceddcc093636833a4ca19cdf4fc5caa5f7173d5c41a0b25268768baa5
+u: 154aced15ae5a29ac5c3b249e94f08ffdd4567610acf1df3ca43779a884c1c61f401d4726afa114443de2819444582f5b899c39b1275d241950498e3897abcfde96c6ac4dadb9d4da0a731993e0309e90fcc487f94e6e8ccadf431325d4e63e1d9b010c8c29add517210d4e3ea2894e80ab724d1c3cb8040dde7d9c78c36792f41781c162de6bbe8f0a076584caae244fd12c2f96cfbd1754be6ba3c45521e876375d575f795f81585543067374826d6880f65a1a6f9676c69ba71b2be3c2dee7c19ad66613366a271ab8a73fc570d4a57ad3a9c4dbbf68a4f011b2bf9dc250ddd680aca882ea146a3e3eaba65d08b0f0524d02af4b712c51d7a2759c8c59cf10
+c: 1c15f293e29daaa1d9673e96fa3703cf00505153f12805ed16ff6d8e2df9cd877489da9bb7090d0e0fc2ec3d0f52399ba27a4abf69ea3bb1a3f623cd8633843a9957f02d8879861921bbc09166b3b3e1604c3e8e8fb21c418f40c332e0b16b83c404ae97d8b6603599e50065398218210864d7d27ed001aaee2b510870a3b9c1f1c8da10110cf894f7273fe05f6a839bd64a20ae4b88f2d78f8c0b4194eba4fea5f5a5cfd1d147c600b9982a49f5d17185fb64dce55d0a9a2d431eb3595d94df188c224892c05ae9a50495c684fec0a90cc665a016bdea6848c9e5599cfe7d8eeb00ee8065835c01de31c049e7b9796332710a508bf96d496eda4e53f65b1cdf
+d: b764ab5f61bab545e326e106ea26264342f4b4288180912a1d415824e5d8e230fe73bffef5476a7139cfd8e89be29807503d34744cb61c2d95f2afaca122baacd7c56f5988ee8dfc274d798ca357ebd3e54c05376c0e08f6cdb50d72dd5db6b062a1d752caa90fbf37064a05ae4d4cba4d333448569689620eaa0a855948f56daca45cf7f1ef4b49faad034bb96ff4877930d5f9ddfb92a52bb0ba9978264d0ac8ba169064ca1a772985798e05489c48d213e384bb0a43ab05f6fee03f590681a115c97d10363532684fa3341cd1830205a71ac7854ce255a26daa1d5e98609902ca1081845ff8bbfac7dbe3c10adb81873b83365abd605b8db595c56bd03281
+e: 1
+h: 180
+k: 20
+l: 3a2e6320476d55574a795f3c
+m: 25c9858eb28af3fad68a2b6d5550cdbd49195a684dd8e3143135df79e4e7196a0ca4
+n: bc462c3546777b81cb5363464336e2736ac2125af4f5d9563c68200ac56f5478258dd532d05012d590cb784c5f5bb21d4ea83c934a1bf65bbea6d42a9333b8dfceecc59581eff06326f1f19ebbbdd02a8b4ff2cbdd786dcd214275fa71f8867a0ee9203c72ee2a1b91a171e150ccea30f2968c085a45a1d3f7ff029ec4e440ad4b8d51c27aafb634a9aef5fea69b8ff2e669f62f5e43500bc6484c78f6aaf2a1c238788b2e2ce9f55e6d21ba47b46f15c6fa59328cfa7c78d007a126560371ec6b663be9966b691ebfa3e1b6ee1228d730872ea4b8557d04b7fb817d18b2af91270a65f2d5ca35d6799a97451ce3a19110985afeb5979318692139be58e163e3
+u: 15c169565e4b9b47779a50cfdc0827dc7ad8a42cdb0dde887937ea8f41c3450bda42b666963c97cd829857d9a11113d90a894da6fb440f39aa2fa5c354e37ee8818039528501931766456c890088e9acccc9a00baa01e59cec5790a28bf86ffc418c88cef4249b74733f0739ba3196219c3a56b84571e0a2b9a56714e5fedf2d4dab869266295654cabbd83542d8001160b3ad8b04b2df5a30098e5b465ac0e705752e79e634ed7607d82e6ca500df603e7dd1a1f9fe08a1d2f1da9bd9e7c412533075bd223d7f08aa0bc212f0d7b608f2f4cec2979fa0081314be3ac3db8441bf9b832dbb330c702a2e9644e772abe1e46ff75b2b679e334a641b8e515c2bd08
+c: 39ee50523835044068b7bb4d23147f98a4c30c93644be04873b92f91534ba5a3c9d2f2b45bf2de2e324dbe033c22ad5419c970ae3579a41b2b15a2c696c3414ef5f06221c4400eed577c87d1ae2fcb118ed4b2230ed6531bba250fa0fe548c8e7499fa476d153bbd72d63dcd7e584c6ec39e5dd566d9d0f80d5cd7ce058b2ce1ae762b30b1ee1c88d3fd562bcf2213637056659de88b243d02fda775f3d472cf4ec5ea8588bdb09f6a67962eb6c92ffa7764ecb2b22afb7c0ec326cdf48e34cdf4b0c102400fd0c554b56064240e0cf83a9da204668f313c137d784ae710d03b72fa18767f2caee439a6e826bd37fa6d41a03cdb176b96c1705d5c1b53c43c26
+d: 43e18d7b53ad66d2520552ed000d2ad5e6247b2eebbc6b3710255dc510d7ad67e8cda060a8df6498011a6bc376cdb705905576d15534268fd072cd11b4f74f09a75aba802a90eaeee97c401138b0ca9a21e9665ebc460d4700e5326b14d5aba80ab3530d3f48e70a17a63b793a68c190f452193da10130a6398d659bf80949977a9933cd71814819b0a2652542ad8abca07b0b98295dbaa41d959627cb38b5c524b115e58261636a1b0c2463acf722cab0502d5956453c092a518c0a3d504cbb5728f106406af4e8eafd02cad7db8635fa9b68330e141317d1049b8efbaa83b83929cc4e2a24f1cd9ddb0ff2b5ac24dccd8a3ef5c1e67e9001af0d654cd6f959
+e: 0
+h: 200
+k: 20
+l: 
+m: 95ed04bc6a75e54586190bf8322a818e70de8aacebe1226585e1b72a3882b0091381d38a3860934b0a7d5443a670a501ca365e0c0178964276a5f5914cd3ce075fc67b5f8866bf9f6c575ab13b0ab57bc4883e861004de69e9
+n: b794c4806df57bc16d58665e9f59cb30d3bad7199b465b3f4dcf2692f96d295aa71e883cdcca56da0a3b052f8e16d10e598d5ed7a7e938a7a9bd70e76aee18086f2e4239ab8fde062719772037ccbc4884780db14877afc42545b48dd8d0aadc5efc5a4edaa2e6e64e07a907d3a6d6b3ac52804439c086f5fa0f190a71b445c7b35b4d68a6c23da331445a3016f3e15d11f8937f69e41216fa79aecf7cae35cfaf3ab08d6c00f04e2d94282f4a3c4df9463a3c583fb72bed110d2c2afecdce0cc3c40cbae5554c0f02cad6c88129d8b2e7e97c7a7844c456497a8345c9e361fe29bb86cf54690bf63eff41574c8f8217f6150938eea194f9d72074a4074eeedf
+u: 164fc91708bd69a695bb0cc95791b29f7f6886888f883a2ca3612c4dd9e9d7e5b2bf75abf840e7219579dd0c7b1d9b05e396b3e9c16cbad63a8fa988a9b4ccebec87978c81963fc16e8774df33df20f5f140436e579e3dd2f6951ead713c9735265e1831b272c425af53adcb9d79e034ff6548681b609c2606bc84bee96bcbba571d5592a77214c2f854f6fd3d46ff97748e072e5f74a1d520b2f11a8864230d1eb73758b96565a772137749d01614bd0c43e48aa9eda45df3432304d1439c91f94e805437f071713762ae075aa2cc7b1b093774cedecaf3349565a45e45a1f3d2b316663802812baba0cb01caba8389b533267d3fd2a9321df175a9a2cf4d9c9
+c: 87eb22cf9b131ad52241d7316003a207d1b3ba0b20e76e48ec3e5399b207df10d0f825d4bf490eb2a3b03aaeabe36b7f5973350492fca6342c6f24ab3bc59173b7ea076bafa6ff5e16b21e3170facb4ad282f0a10e47fee8b623b33b8960e9de7994d4bf2c04cd46fd329f13c7de76154b39462fa76d7ab9a445444f703518ad49a4d53ffe035a17b74283fa18c6b7f9c046c68aa3d4ab8a5cc2a8ea7763f080f7b2359b17b8deda3546f3a5977001fe936969cfd0b58b3313d076e770b9713a828fea1e637927a4feeb2f6338b3a31c81025c1e0fc142f87c3cb469f5c5c642f58a27a36ec01322aed0674374ca62722a3aaab926b2095488576800c7b86f6d
+d: 85d401f2cbbfe757487c5f6ad3c339acc4bce650b44e7f3a0d0f495080ff4868322062172129a2b9cb01a7700a60ba2271bfd4f5ae8852fefc7bbab24f66efeb8e83a6ad6bb080c4e2f6d9a3357913ed31274e33f0f720c73a0f725dc98daf3a15eb59d91a931a8cb0588cf73aa763ddbeb1057aad81b2e2174fdaf59f5743bb648efd0cd41a9139087c12ba90af7125167b345a4f8232714f6e45a98cde8a9a9108cd43cb12c984cf2d5ad4c6dae137fbd48c9a98446df278f645b0f603cf75c1eba49d80f284879060fc27050adb791b869e92246baf2ba72d011299c8079b559a92f5c1015f3e6a0948e2538f9502926af87313c2888717f4443ced7b00e1
+e: 1
+h: 100
+k: 20
+l: 625e68585b6a7b61502d6833226c2c784647486744447b30503860246c6d676a35582f702e35505e6a7058406f41612b4d7a4f3828417a4665667724763c4b79295c63632e4f75637a77684d3653536b787a2a3a
+m: 2487a4db08ff581baf400f7f526ed6f613eaf12af3f824e85a74437eab61ffd23676cd591cd016f058378d5e843e0f4f4f66f39049013b1a3114e6ef6db7447da7b58a613b57804b0047ff915d0acf9c009c5f26af4eb6d9583eae47ca54dbdfe4e31f9d63837162543e01dcb1cd57a301837f4449
+n: d73e0b73a8c3eef4eaa324cf7e6ac9646f5630afe06e7e753bcaf720b5701054ce051a4ee0eb3deab9c87a580453c3010e0301eb5d7239cb79923a09c37ea04b94d72560096f9493e386a69334d3408c5bb3e6f0ca847247fd87674ad63b02a3206065c12700cfac6f8288a7eaae57d6331b57b3b94fbd7ab95243d5d8a0731e9c12ac890e2fde3dc67340105631312a358eac101523c15dd455c9ff85f2afdf758429f29e572a0d482f8f004264cdc7705aa2be18380f107717709b5ebb91d6753d577a5e790f22a2fbc309c2f32feecb6ee7d94c6971171c8282ec807eb4533dff216f2467896c9a79caeb1de260e28b3bf1e6e64d40b4a55e64c5d09892b7
+u: 13079b27e31448ac828db01c96b07a33954ddeba98dfaa00b6899d715558e445701723e10f430117f59ab56a5f2a40f6a4dfeef6c824e27e6e4afeb23c0e745efbb08b0d05c5815e8366c3a36469535e4ccbce892eda5353282c3b6f0f8ca9dbd86d234ccbaeeb44a7da05b4695d3d475a929e7e054b4da48bd3063d9790ba728a97859980f61fc5510d55a1a116dc11f378483a78811adf98f24afc5afe260c1efd72bdbb1f47c7398f547f92073b563279a1eacc8d513045f1d7cbd531924c4e742ed7aefd00095c3d0382fc946fb6dbfc752f991f822bd4106674cacc2d725e4b759bccb23ce4bae68b9d4fb6ed9b475a573be6c9c80b0036643fe8f0a4eae
+c: b3d1592c1d7a9c2c4c907628793a8ecd2f4c0d8f88977073af434fac1ee9a3c9faee761a79974f8a129d5cc56200fb2e707ef42dc37ead586778bb29d58e81463f75829c9123975428a02726d85ea53e5710a8900c99fb568267cd7be3ad885184a9a897b996e465f0594875f0c251f6253c15bfdd64f655e476683ffae534ae6e7481fdf9c4897f8d680e0231ed54ffcd6d9d488782d13ea7a8089f0bb94bd6c61f729af52078d0b639f53c17940e9e8230d330a6d366d9b98c5235445e820da7a439a0e621bc9e9501bba6ddeed7bd98abfe5769e3204d6c6081daf56158192929638d58ef130f9a1eaa9ebc983a854d5a29ae0ccbb0ffd25d5090a7a959d4
+d: 3b9a9ff24a09f5013b582ceae2c921febe76dfc1a5df531e555b5f02bf04aa986e9468757fd7a076643123ea0dd0b464e55305dee7ddeea91885e75b715319f35beffe48a113395d042b04b631b60a96a793ccd1d0bdbcc199148c1e7f51af71b1b1fdcc057ef0192dabfc000b0bf31f58a67cc324924ec378fa2d0b2414d8c893e4e540ca826ec282369098480af4cc510b74a6404095fadfdcf995e474b28dd511a299d271287e1dbb41075dc7adc67122d687f29d54cf307dcc13e5b0537cb79258b708731a7f06b08561fb121078d27f82f5810faba68baea3a5dc819c6d05eb0b05558679db9b0ad85915a65eddda2a2e5cbaa77c4e4596811d07fab589
+e: 0
+h: e0
+k: 20
+l: 
+m: ddaa53088f844199602f4f9e0cc03e1133ddf0cf77005d0a0af075872a47702e7f1e0cabddf00f95ae365f91c4cea5715deb054189fc98f7c77c2032e95adc0c8931ab9fafd3dc7aa2478d91d5e121fdf183270ac92081b64f7dc0af631141912e3f42167496fccf035f15e8c0909785cee0d7038b1b2f7cb8a525479c30c08a
+n: cbedeccb3907c088a5195b33844c07527abc64228e58ba535255f08d5179f95beca8c18bb46caf7a6a67340b68e8c9d3e4931b7d7a2d7266dec6845ad5d77ed2c92ed1c0d47eff301eaf8b0c79916cc1ec6302bc0fc3aa4c04176e4ffe4ab1207a5cd2f98239841c76b195ce07b9845e158aa684c84680c765afdda4c9b30122a3276b155c793656f63ba3487136de8cc0ff949e8551c7e1aa0dc6cbc236b381a03ae9dc4ca00686434602035d7a1055cee97bb4aaece9fac055312b8a17212c5b06e851bf215761fd291f0afebf3b03e6df4466762538c1c23dd16b45f33dfb7ac82f4b8d8d42dd778789e5d961da6bdec52f86ab2599e0b34e441b48c29573
+u: 1415dba9ac4729cb474cc2e4b179d8ef80f6c8c6e89b37877f781c5e625a40b5734be0366aa4fa8baa473e847b5898f610cdb4f755d2de28a62faf6b7d5c912aa908906a2534858a94d00f5b2a5c5c7232d76e9e1e6a0a23dbfceb5ed781a08dbc85259997f18ae346438f5f613bc1a7148ee06ff74d47d30ff0237eaa237900e62e981e8bceb685d6f4795ca0a6871ac19f391c3fe458d24badb295fd152ece78e592b98026cc8b9abe1923ddffb1415a0054ba0f95e9248b1a7e006817d3c2530c9483613db681d5842f0f95aa20a23a49d4b958b0dc5f1306f8e104f0a14b081f83b03c3d708e3a3fe83f4e0fbad0690012fdb2e58d8b5458634b338762d8c
+c: 11ff5794df391ce29d80a3b6c8d2ded8bfe3a824addf30a652367b42b9b4a354443757e980611070290fd41c0a4dc2535b86a568814e247986f9fc8b2544bc4c80ad07fe1ce87ba00e6c41d9f165fe4e43a85a8fe244531fb0c84bff93363ed8179c97ec2973ac0c4aa956a34385176b66334a61ce99dd8e3216dd039d2bf413443c0e801f0c530d213a39d35286ed30a003d7e1c0fd0afc50514a26754f0197f243ff8bcff6c8211729257aeb29fcbf6422f7dcd51ce915a7f9cb9d9136db3d10957d0b9dd57d571d90ff88b8574518ea7e446c44442e60772ffe646f1be0588ebdfeb8eada37a44cf7432c05b7b385d68735e7cd53d90015f7cc1b1b737022
+d: ae86e8ef983979b0bc9a9db6afa7b249bb6883efc3a5dc32296a2d2f01c4e31d2eb500aef36e016dea999b9558052e5556ec6da0f4ecc5765e37473218420c5f5a5cd5c7c46fd6849c7da885a7cfa87927119529d39ad7bea933477c4178ed6ae538d0f068d348c9d77f14253ff3e235725a59a7affb6d4ec882e19461258b2bba2f8529ea14d020a611be835229dd640d24742c8a7a55bd9d8b55c277634836764ed14a954cf2c3dbad66d311b902deb3fef213b4b8286f620b8d066647beffd287ffa622740afc58164ce14ad3ea16e4bab159e399470ea24fe63fd9150137bd599e6a59b7ee631d482d18ddd14952718769cd33d8b03408c64d2741d72e41
+e: 0
+h: 100
+k: 20
+l: 
+m: 5ced488df4be16b5278ab82cc3129d399411209ce281e85662c1c5af55b97610fe051af414417f71264a5a6ce4c79cb60890dbb2c07f07e75488b16b9db4c50569370fc9cce1169d5c5cf06703c826925bd051f399fa1525a07c0c854630ba067a29f3d2d9f51a86c22eba27313f72a9243b80cdda42845dc20e13596089b1ea3bbf5dffa5c0dc10
+n: c3f5b3175c25d990204280109ea8279e9f8650a3e3de047705c71760aa3089c2d7a56ffe5577b77500a483f9c0b48418b4f3b7b107b46ecd24ea1b816bbb3269c5f9ba92f2202dd7e1dec0290daaf576d9e969e74b13828d77754dbaa54f332d9c96917c3f30c855b8158f3900fba77fa2e0bde681f335274d191c0fe38d831c6d7009ecb9ca8d5dae479a5e948b85f19bd6feae02e879f1da4e929955e4fb400e11ea2a5ecf3a41e84e99b62659570c0e135a6e3b786b9634b54a3363399c34799ce57c0016c9d409746045c5905466fb31b1fe5b9c41dc7b31f335ec9dd0724e2f5e5cb77f2988122a8e0876796cd358dc51b8d7e1de95fb70fd9e3e46e1e7
+u: 14e6f9dd292a8eabca09619f54d4632cff0072f1603d9e6e9bbeda767d6cd5fab081b8b80330715b4a705ea1554f4c7aadb8e172a3f5fd51b3b7e85dddd115ebe4602ea0f6f47758d8cfca123422e4f636eeb377330537be3fec34ff2c5420a4a01a1bf7f9e5e2ec679b1f34f71c82c1ec9e54dd17cffd4a4941c6a1344672f2ab9fb1a757c227b0960813f3cc829bee9394cc80f4d3fdf713331ad8347cffe7714def52a2fd71fa8637dc33f315476f8fc7a52dcc0d9afe617e20d3cf85ccded801f0b4a8f1e4ffbf31a46ee3778553c2cadf51b5256e99ad774044eb8e7523e9e1126dd8098856f2d79a384feb5265de481d80fba401ae6cfbdb420fdaab69a
+c: 45c3f7d93fd810b7ca7408a892ae3f8abbd1d09329e8394d962dcba06c48faa25c73d647d185c09e803bc938a007ac7d88de3e522b399d1c4c522c6a408442f0a3f12f3f69b5e3c6af7c1938356338ef7e28947222fd41dca66a5ddc0793305266339c6bada22cce7fcef39195bc7fbb157d34aefcb4997bd898e704ed69cd9018890f13c654c84b9d05faa8b36cef06c28a9e26f0dd7da0c55eb45b206b7ae7289e8b18727dafcf7c790b048767d7fee3480031fce47ba59321afba03061e6625db60ded2f3afdd952b37701e15ade1cfd4081712935297c6c6cdf3e2267e6c3d9733c3161e5eadbee6fd18e44b9e23c15f66d9b775aa34b2f2cca5cdfa4055
+d: c80524a471cc70600067f3817ef050240c390135f7408a3361e9018bc90e23d57a3e83c710fb2307843cfacfe6163d0b2587c9e7b3de342ffe9cc552041415b3a1b56daa67d2ff79a4e28ea010e0727ab5fd5ee381cffc9ad0c9eda0e91cb1d973144ae5e69c2e19831e748d2636091110363eda8a5afe093a800c362b1f2f5288ea48ecbe5052a738fb1c54c3235570575e3f0b714a1b80f1089f74e88432799c12a351679435f5e9c85481fe9f7aec3f4b52adee385108bf8606f448da8e80818725c339a174bc671070b140659347cc02e50044f4f1627e5e3385e116d7728021456a8418b0a595b88e75858a3db8e73836a0fc38bff9368ff82e85bd7069
+e: 1
+h: e0
+k: 20
+l: 5460744f445c2976502e75562c37243a37662352283174775926626f3c717441315c58684d3a686b322037646353632d70565d577535386a395f6c562c5c675e5b61423055224763727c62765c77773531737a275e40286c2c7e6d3a24555b765c6f7c775e39
+m: db62109ca1836943bf57761c3461d690ae1d4099e0e91ac46eb0e1cdaa2a5f21a308e63eb8dcd5f65091423888ddd79feb534c3cad3d2304fbbb12e86e5366669d46c7d5ea08eae4c603961044d7e767249094d97615e5
+n: f122105de9209ee2f8dffb861578f7a4a06a4cdb59f35bb58589905ec250ba320799b5982fe47146817480c4f4feda02482a9aeac66bec4ebaf1e2f543e1c6ab963d2b06b06fec17cf929d74b65b667ad7e9750058d9403b224318d5bfb5af8cf888ee409b38a3b6f087cef796a4fe57c621aa6213bd004028baecfff6c1fa9003e9621914d3e813923c1aa769ed2a0c19f6d279924ee2d98d88d16930568daf81396baf09ec98511011b47463df6975173496697570e06adbb433225904d5d910c259c35686ab567ae1366b520d8431780813aa0b498d507f1bb6ec880dfa7adceb791ef610f5763d26d5b700d557a5229b327fb6caedcda1ca334dfc92d5ff
+u: 10fc896d209e2dcdd0fb3c9e3200eeaa8fba8b8cc6797c2b3254e2bd3f695be75d72fff4f55e585cd1942cfd0120117cb1135656fa8ffec047358106e70c3260e891592d864bbdef90db29a1b5a8e53406f4034bbaa9fc49ba1bbef6e4936d1d82512300ef1bd4d2ee2b65a07af1e06649b76c00907d7f0144210658eaf30be082469ef79322418ed290a4ca32ae12920f08bb7bc9f85c851ad681fa7af5c09d781fc6621af9e1a7b539542f751df0e987429d43feeb1278d9b270bb2ad77f6115870c9f33bd3623b4650d84c83fc6569c35a8ef480b9897657e65ca125178f4ff11939d97e0a0b58c6aba8680dff93e2b3fa9dab445edc2a679380d075d1a914
+c: 53b162a1d6dd4db7f40b030fedfb918b4e545f1de8126c918c847e41499e48c253202d3fc9261b9c7bfa5a8671d5dea6fb2149480156e258a8907525dc653ba73b64538d162e42cc50389d1d8800184576216a2e5e5ae3cb1d6f85c1c38d314e76021c23a82893dd2606ac633e32e3dc27c18ce91e5b354589a20f9d0d8eb603b2a2e75d6be3d71fe5934328efed58ed517710da8739f6c5ac3343945f34c168ed3f35751db714ec8747e24563eb8a0a3a52c70b3da90613f53a72df4612719214c3160c2920d6e6a7904eda2e471e252a5b271af791810075a27064ce5b99c5fcd18179e736e58ea91edd5563dbe389cb441b6a685dce1dcc7e0066f655bd66
+d: 51814c69b367da06320e02aca1cc9842e728152853792d8bffb333c2b0788c79cf02a02e7cfb10677d3d92e6aab6aca79202924a96a9bb16644c9ea3ebe58545166c3c982f70e870158f9f5ec50330e91ba3f3344c38b423da26a8efcdec6b4e8ad7cea173d708858d8645c00adbf626296eea797d39ed40c01139d28de85821a03f642701928c202d546400b2c4b54843776b7faf5491410f491400426f3974f04a7fe6d4c2144cbd518044f0ad4dd6ab26dadcde1fd049c6a5395155124b3ec60464203a6630e31314693751f0e09eacd8274686e9c9d84a000badd03e7a03747159b5a42de3c04480b479a8421cc1c623bd30b3589a20bb4740965d9a5dd9
+e: 1
+h: 180
+k: 20
+l: 5c3a7c315f73532f537e337c46245c587e7c284425756d765129207248552a7135325b692a412d41284d285d2834234a783f59685c3b7375213378276e68245a365874665876627241227e473d672d61614a635671786d4141597b73613a7c62332a6d696270795d586f795c7e3f6c61305a
+m: d964b388c363df5bffb017875c5e84001e84e0ca300b4b79200fc4381d25af93c1d88708b30977442189704e74bbbb4c87580dccf39f87618ef20ab603400cd94f0a4257cd158584e9ff7aa09aa716e3e5395bd2f5e4e3a8178d710223945d1ab43f6c08fb24498efe6967b0342cbd6eadca80bebe9c905f645c79388f1273bfc84df6f78e2ba443604cbbdacbbf47b4efa9
+n: a77165ee6c969f15a4c2663597f5bea867831aa75ad43b95f43274ae1bc69d3173f02b268121c584fe1b4d35734577424849ed57f3a4f2c49e9009817805d9f79a833ae9e452b80ca18daf8ff1c37e000d754608def00ebcf0590109f738fe81cf90a09222c8934ef4e6779ac380388306a9466395f06f88d36c0158ae214156113930231cab5a6c2f68da8e55975589c4ef42192702dc2da28c467be59b6a03ccf93a9169226653cb1f343e42c9ddf69adae062b659bdf002420c39d0dfd14d2ce3755a301534e2668b38eb716316b906c773a12c82c9056829a470368ebcfba786bef7abd1f0942673b2f9f8876bb87a6a85d84ea04f2fbc407b19b0732e03
+u: 187649a72609f4af83275e9c385b7fd046add7f189bec72e3d41d54b311e39ac64dc7b7970addb23d233aa5587cccf4bb3c310cbef688b50550aeb1ad32c40955a1375b8ec18ab4fa52f0493b01bf48a2d144f6d59b187c5d8057ed4c235e711991e3f92961b8d03b1681028468565d49799bfb80e1ec3a5bdaeddfbe542068488f6fe00dff1845a91830aadbb7664f96d24475983f6d04e8708ff692fca6708743d4465f6a614f19e3442d1a6ed4e2ba4e19aed698f16bc1ce955982f121bb40bc41a82b17a4626f077f2e1782d6778553767957d38b96c06c9a9817651c8314a16c871904aa7d5db8664eb52f45b6bb7b0b7a369ca3548c32f0c3b9d8e8f63d
+c: 9131ad2959ef6fef8fe597c0fa68f55c22f42129a8cb1cc354980d6638fe04e51158eee5699d2736e582f5b30909b1f44a2c8a16de950bbb02de2e5298195ed84cac9e1ae9bf479c3acfceaecc2316c400c50f52aa17fb507715d8219c37fa7f9504475031e7b10cd48b1bf2155fa395fe709c4fcb7dd2375045543e722b7d3208e0e6b1bda6d4b5648e2baa44c9d9853865d3a5bb2921b3750ea7afc38a0c30712593de454130720fbdea5d91e14834e3e9b04f757e60a97bc9bcd7056294c3dbe80c550b7d73ade67ecdcee3817367f08ac60ef8155ee35b92df751aa3d4d74b636a7943001fd16c4347aca495c6b7afeb1726ad7dce2f7f1d9e291b30424f
+d: 37cf5b135ae4f39f917bc82c387f270c3c2db983873ced7314adce7d77c4bc3934766d505b9773c3333a82ad75bb19352a8bbbc413eaba894f3e9bf449a5fc534ff9479959f9d61cf1e8453898fff15eb0bbbb424bab436f70ed92f2a5be612747217cbb4610f47f730088814bcf4febfe043bb7d6749d6214ee0faa59eb43f332edc5cdfce83f25c751ecdc0f4911166d309c82a0280faeba81af6d8cd56e12988bc5881614d06b203477d373cee6c1a1738d44cf67edd0c1c080b4dfff7dfe200cb70ec8202cee01016d730c15eaed6a98ecbb3826ef1713a945b1f40c6e28f05708b0a1cd5607f6861ccce476da7f231f7934ae23f7af772ee64d2fd307c9
+e: 1
+h: 100
+k: 20
+l: 36694a625b2f6e3f536f6e4c3e2c57546632694547383329784c4a384f65447c285235453a5c735e415764526d366f3169565531674e237d6e4d7d62576f5e7949292b5a402d3d426a6c6a6e69725e2f7b337b6b
+m: 20baf82f58800a38bcde5df5b1106450d28a9a77d3934c508c75f87d649f631eff1a97243d3fee8137697db675cf041cfa8fff8fefc4c91029006f3c0975a516a60a8ff1cc3e0d3c27eb8029afee3324c55e2e6251891316f26d9ff84c4ef39c3d2ab6d50dd1eb738c36d6183fe009ba07b52f0f
+n: 989df356c7535dc5381d7fdc75478ab511d11a868e5443efb3713d53bf816633ebbe4df6d2c56f7b730fae0c85ff9aa7670bd6b9381113090e4a97d7366ff7620a6e87db9cfe0e8e94b420e8c23e5d42455f429cab4f5b2ff714b33342377da832da8162d626b20c6da346d701b1b88d7d8e682b6f1dedbdd71c91ca234f57d0bcf92342c7e10f6411a077a546c9c55d19da2c71c7b12ec046e68fca0afa7c762f5495206656655cc9108b62312fe00fa337c8c413648158e7ec2847753d6bfa2cdb86e8918cba8c656c2275c881b0eb2d9d2b0ab068fb1d0cb114ce27bfab76837d5793f9a21b83ad21d3ba5d3262915a661ae5736d6b9e4971ca4e9558a98d
+u: 1ad6a32034e462d652c61f6778eb1da07212cdef369ed36f413595eb89bba6038bfcb46443c3f35ab2d9f74a5543d15a265393751d2345f77d64e5ed4acce40d1650fcc3c86a3d86168a8a1cb96dcbfbf515a8002f64ab71887959aaad97fb4906f28f956bfe7284b2a0951b4f366c470aca19afff3b14928ecb6e148cbc15fd1d4e6e0c7aefac49e38fb649b1f1e9da832529b4de070bc773fd1fcb24b20ae042ca6b954334be912e14eb3145429fa3344f1c5962305fea0e93f1c115d41f8f3f9394a332ebdb7afdea56396b0ecde3534fe2b0254eb9b13b57ab5c3a5ed72bfe2d99ddd48ca2216317f8e08d46ecb9394af4e1e1ac310738fa518426985c535
+c: 47b2f1d32ad8033057ea92dbf316a11693b208a3ded783ddfe8d9c7b96a0f5a177918742b44f925a3f43cc4e3c4317ee0482a7270dba4fa2afc622fb9830d1f569ae927221819cac55879b97fd78b77cd0bd2209f7b018a69cab561f050f6915abd97efc6f3aa9c277840be9ba170c0e5c2696926964802582f48a6bd1f8b9f176e6ab165bd109b7fe7aa3cab9e49a35b8d3d01db9d9a566eccdd204d0f3d91d1dcc1d3151ea2398353075d4a59940c21e6b81911cba09d667e22bf5a3d0079c48d087b133116b1af4b99dcc65e06b2c4d75d62f21b3f6d5aafc1ea3555c8acd78580fbf8cd9f3fb308b39c7e69d609bc7adfd4ced1da4b93eed998252bf1d96
+d: 55fae2c2b41a05d4ec6522459d81836d09b91a9b72dd0e09c731e1165cfe6fb6380f8b91273eb67525c5730bdc944d7c707ab4cdb1fe562991ff33ee7e27f2fe65a3830a74912d0fd720d4681b4cb85011a13666c7511d3e4f370f4a2f97fff26af9bac9633a0bca0a78cc77061dd7fb9c36a27689f227aae46c01d92aa892878dd5923d03867f31cc796c6cc1741bd13c692e9f9627f86e8e4bdab5e4c78477e2e24bc3d0d2d5503d8a51eb45001c48629ffbdccd08ba2bfed5dcccc1a26299cce625b51bd7d8bc0a6fa5c63d21a937170c60bd564057c3638cc511f93c0bdcd43db74f363127db7e9d09da5bd232ae1b85270987fca2d56d3882d518c2c9e1
+e: 0
+h: 200
+k: 20
+l: 
+m: 9703ff18dd23ffc1a3638fb378a9c6198cdd1ccf4b35617b26ec8bde459e7a764f189dd66ceec5d754368042261ccf07943c431e2636631350e4856a29ee2544448d1010f5b755c99b709d85d6f7542c9e1b627239e29970ea33cc3cf61778ac2bdf997a7f48557bda7f56231d58f5e737fe84ec5b4f1ade438e
+n: d9695bd0bc58fe6dd1705eeda55156c487bc3eb4e343136841dbc5d846373da91df216cdc0961cc2e6b8518f5b02d8663ad21f69ee9dc3094e55accf71ac221ea03a8f336ad95b3792543aa41432874990cb5094374fd57b7d97f51b960ecfb94eaf1f4d661104cd1d5d17cd74255b6122a6e9d3c0f33c15888d81441961d11c6c28c2f8aee0d7b1cb1317e6d6ac3375838219b4476f5038f6ac6434836d44bc3a41c2314c93b27c1521a10509d4d71c82713fcec52864e9c45018e844f765a84256d4999925e328b617585a813973059f1355a3f89d9566b75045c1e8feb93546b4236cd251149a1c9cf679e55c4be15d2b1701254297caaa6fabe029d39acf
+u: 12d70011e9adc328fc469d66dc35c8df371aa6bb2074753055bdce97fccba65ede51b6aa47753f2b96c5480404666f93e98af4453faa482379a8f71fe7c3c47d2bcf2dd1350dff85da363446f57908a21150515d24440b68244069e5252b0d6eee7844133512ecc15d1ea47ec84aaf6a21650519c88fa411cfd0e538587975c92ce3a51c3cd3a1e767d8002006cde7194de3c7799da8fc316211bb0793d5277a4c623b5d78dee4013b817f75f41780f5c1b57648ff71f3491e1d49cf6c12c1b5be6c87b3fff8a8c86d41262c7e419f2b10fbe85dc4bc83a8da732da2f3a6edf41a250fb308a6c101061366709ce85e75f87666bb7bb507db550fea3621391be63
+c: 0caac1f4a3711bdc1b3d7babfa2a8f6f8c87ab0dcaa12f0d2f547cd4bd8b3590d43b6248279f5118b7a6fba0b4985d3a940ba60e494dcc4f1920260a9ff585b0806eaf99ff318b9d587033bafb400f8cfc12976304b993ef02afd49156ffe06772ee88e3ba4a16e48ebf6f562820e44c78f5a6209726866dca59fe101cde34648f31bd81f471fcd4be066cb692a5f658acdf829a739e22fdc5fc71ffd8771e49b9b3f1eaf9601f4d838f533e1e007cba2624e478df5c620d185f2d62f98382b6d8f20617ab508d9f61c4c04f51565b896596e993bc2ec02fd88185079b2d55e7437c26d95870aa806d3fb8e20e999a0ec696ee49698388453175b681bdc7d380
+d: 33a8514a2fcd429336a42d84a2f3d894247f13d632533391d74614956486c65bcf6aed3f23b2b7836812863699ee4dc7f0786290fa216d7ce8815d19cf5ab70afc7af148a74219153c77043de48c9f9b4de3dc8070f9f789c3fef73f4bdbb97bcb8d80b9f37523245a598101582e068257ad2af43b87a06d6a49fb7a0bb3fddae30015505f7c2c133e8f455fb5070290fe2636d5c0c779971568b6af759576b3442d21158bd9e8413e303d7aa0f280ba6370e892b60017fc0976cfd4a706dad6857086616a9119cb7107b615f1cec97c39eb8a0355c8f234d25be21fe14c959038bbf6bc332d655dc061b0c02738ba415579224718046df0a496b077d477101
+e: 0
+h: 100
+k: 20
+l: 
+m: 0859e6b8670529e2526b674329d508a09d4a024a19e86680f38ca9ccfb02674ff8b7f020efd8784e9af2cac93ffb94e4e457cf47291eb330f102ae7e45bbf5d60b46c17845da76050a7cfa42da0508
+n: cda10a7ce83b7f22f92620fa0956424d13f3f06895ea32d4a195b44c84caae309a5a022594cd6c116894fee5e13a163d2c89a01d4e27ec91a1eeac1596d58ea480772223b588174045d9b2b441d7c2ec0eea050ae84748f3bd7619595cb82f232832f17004b676520f64302f29c93f3279a5fb0bcb317205a3d0d20990c3323e83fecaa9e9d1e476d36361f6ee459e70b99b431e12e93dbcd5a6ad7bef0f29fb7b0ab2fd761989fdc900b3dc774331cc55ecd1b9360864330e72e0bcd6bceeb1ba6af10d75fdee2d12e1247339df39e9f092810cbe448196fbc0dc1dce5d9a0a30935187bf8b2d3a541a4637c255376352a8b92531f6612d04dac2c84c4cee19
+u: 13eb5b5e705941ede70c3fc5926eb79d5d49e88f44934c291875fdf9d69af0d43d6e66caf236158f76891345cca99026d0a71dc4eda918becfffbbb26fc90447afed74a00ffb732a7b52104c97f55c24aef25e41af1b66fc946dcff64a3b068e1905556e8162d26daf0bb081815f6029a1c8797ac8b58156087e4835a6f4454f5ddb6a65287c88b8aff9192843c37f9758924517fc72f02502f5e69b9a0d7702e5b6fba37af7e2fb14f3d426fe789ee2dc5ff04a0543df2281897bff0e6cb6a0635a11aaa5b0896017243b6143de62078267cbab80423b9ed25f8b8279ce5ef4791fb80ac49f2d5b7d1747e03de99b04cea43c553342f0e8154d2c91348ad37d8
+c: 797af6127f97df9f46e9424fcf2ab39cc7d0e0e5fcdeb07ac137355f0853ba8cc2181197c4df6b3504602b33a40dc8fb18ae2276d1c963ea495f0e3465489b3a335766a37c9edc05b95fce78c6fab526f2eff30393ad0ab90ca8732f883e56a0937a34dc0e243cab6945c02b996df64264818baed3c8234533710ec67c5ffd00f476e666533ee1eb2a061a2afed0cb61e00f11ed6e8bf058a3de56281313dcfa1cad46e28ee1bb79fd62ebc34132ad2b08cfeaa6d100a087a0308bc6c8c9bf228a9f787527006bd1729a76db85e12186da5de8590d2e6d235d770b96bdf04ad03499a284f5359a71d094e84d36746d2e82f99ff2abd2626128fbec60d8b77778
+d: 92e5b2ccbc37db07760d48d7cd1bc7413cbcb800af958bed5235b64cde8ca7cb28360b9146f5188ad88696b9d101da45f9220eddf723ddbdde26b738590c77b118c37a1f01e736f1227498ea8d0461c1df54ab931669b41301bb557fb54842a8576b7756413fb8c1e2a8e36426215be98d54ec0d77c8d34d190d122266253639635cea4738a1322eca07d43421dfd7177f6eb31a12890bca47882bfd217e22f0fa4492a8759e4cfaa7243b1b70be04091257b4bd7546e7064a4df2a9df4a6a5cb5c358efe736d2ee904f76fcaf495eab7e71c6de4787f8231df7763d148c238154691b7ca54906e3458c439bcc73f95250253fe71101a3227645b798b96bc61
+e: 1
+h: e0
+k: 20
+l: 5843647463506b2c7b265f48356b355163306a5273693e6c7661735a
+m: 8bf99a495ede6a94daef9d4ff82d8014be7cf35a17e85ec1ef76700edeeea7b8b25554bd5317f192acd2ada467d4da535e1baa37146bcbc33418e1bef313d68c88351c21617c846c97b35b74ffd4f2186e2e773e7eca6012a118d84443a3a14e10
+n: e0aec784c618fe46758356d45966ca113b1090e792c60b1b23325548f78c8f88698aeb96315d4be6ac8e24b5dd8f753ea25dbaca4fed636d869f93f936e64a2a8abbdbe162e18ef666b3b0450ddace8512ae0bb572e26db8d13ea837205bb8c948f5f489fe382c5d7699c038a5fbce5b406bca4a651485f652bfd3ed9991a9c5fe6f21e82e59f4800de276551fe18a7c46e223a6a2f6ad982ad9e43f6589a36dd27a33c84909dcdc5d88a9585d8f5e2d99337e954881c91064ba1cc8ba101eb349c8e26f7a5bb84653f8d9c71a4debe1f0e07ccc5b317ec372e899b5ce69cdfa75a3774260ed16da4a221e4aade84b4aa393c6c228713935d5c61e9a8ffedf7b
+u: 123aeb2357aaaeff38ac8bbde36678d9ac75bda3fe75565bba03819bddb9c3671224fc45ba7aaa63d96b2e5bc76f818a31839b3a1aac1e956e804a2d56a3559a06f2a9a758147acbdbace496fb6de3abd70d729deae829cebe73f9998f03e05592d2bd061fa26392696817a569a3036504cc4e3dfaf323a8bc4303241c9f23bc6b20c32e2d6d25ecd5c4dbdcef5727b619dfcd16d09a48eaf5fc08d46c8c0db5ec9b09eaf52a9a42ff935eb871ff0437f8c20140092da788059039c63fcb7138b135c1aa94d95a9ac0ca34a6acd828f0d7a1129c6b49b52d7112632b18908cc3ae9bce725a7e9653fad197f8b5af28c9cea1a2458c638dd9165d2221a8620d146
+c: 84b5c5d04861e4271ec21b0a0a71005cf046f7b1979dbfb8e86f3024d44a746fb02d10de663dd4d0b60f10b1a15e25eedd3d75e2180999ccb90bbbdabdc453c4884ec49923f7cd0d4c1219c38c4a104ab653343465695f3c6a4cf5905c5801eb3f608c058ad71b9b687d6dfb187ff5c9eaa72bdefa0a23101f86170cd541659cba3a0680f86695e280d70473a0efe7a5f454975db06d83dcb13c99abecb774d8025d9b01502ea138f36e98fa1c93808044395aedb92287e911745edfba8eafe460141e4f80d5b47c20e842120e4d71b89ad55d5fc695a9d0153dc79acdfbaf192ea1b369930ef26f2729f845faab3bede9aad277807c3a23f8b938ae287d6d27
+d: 9ff8b175e4c1c4300101ec8d1c6dbcdf5abe3a3d4b77053e63602719e4bc6a2a650149f8cc6cacba54693a12f58d76277a4c1e3e8cd68c16a8d5c24a12ac70c213ed5891615d6de8aec3746c8c20866487321098c7af62224b13492ca132092e905fa2748b6b6b3c73ad278690df235c81f2307a6826442e4542d6d9f2b33632280ed29a0547dc272ab9e7f26f30f8cf2b1f5c70ac2f392d2091678404ba10633efe03aac81bc9f7cc7f6bef21f9ff07fedead66665f548d2468662d4a29845aa12443a2f061d9864b8fbdbee1d0d8af321560ed6a117403b16fa37c831dee2576dac9e3c866adcf1558c41151c4d7361ccc3ab7a498c65ec9a5614b4831f6c9
+e: 0
+h: 100
+k: 20
+l: 
+m: 9d36fc224448f4b5a40df0affbdb41182c13f45f36ab86289593949a0c7375a4b2559e98123d8ae1db51428129d65534c59d3bd56ecc26596c3ef742ad159d38c5bcaf2593e5
+n: a3d61888a6ef2226e1db0043a122516a730df4324930037a66520fbafb4cf24909f8dded747969e72522acc0c711d65b9f68a7235f90da21aa17f5b9d373a8721d62c59943e9ac885fb5c326c58b481b39e70b2d4cabe32fc8972c9c24b8468220e6c38632c8726231867fedca80d7d228a6045ced75c8298c302acf25b7cb1fd13cc99ab186f2f0aeb6c603ec67ad701b42e04c17184e984b9bb466cd05a69e8822c2e70dc494dc32bc57d4bc8505756ef3f9e540f0d7b7cda6d2ab34b74b427f61b4991cb9511ec35ada03ca40710df08ee30c6b72f819b80961c4ec5a8d66f8a0d0361e4eec14418f6530fa853485795ff2b8ce2777c76c89343118439633
+u: 190024e1dc70503658e5dfa4a7c75c53a1167e5f1472e2b3760032edca8d48ae4158b015ed770546deb1b41d5becf1670b956b30ee7829aa35aa09627f81e056e13e5f6dc1446e504c73a83c2b0c84b14533fcd8beaffec8338122cd2f9b2a56008c175d0efd3ece5d1caa5ab467678e443a29fbd112776f5e6c906eb036054971533e011ea435528850ddde41b9a83706bdfcdbba55b0e153b5865a909a528873f55d53a668af9771b4318933aadec1860c73ad14e811b595f68faa45bc23c36ed7dee550a30bb272c2d1acdd5fe9f84083725147d1ea287817d4c5d29edae6c29c3a5a836b7d57c6975e803f6ae374e801f34ee18a192cf4b274c63aaa9dbca