diff --git a/Data/Digest/TigerHash.hs b/Data/Digest/TigerHash.hs new file mode 100644 --- /dev/null +++ b/Data/Digest/TigerHash.hs @@ -0,0 +1,144 @@ +{-# LANGUAGE BangPatterns #-} +{- | + Module : Data.Digest.TigerHash + Copyright : (c) Orlyuk Nikolay 2010 + License : GPL-2 + + Maintainer : virkony@gmail.com + Stability : provisional + + There comes some kind of description how to use this module. + + Assume next import: + + > import Data.Digest.TigerHash + + Typical instant usage: + + > instance TigerHashable k => TigerHashable (k, Message) where + > tigerHashUpdate ctx_ (key, Message {sender = data0, body = data1}) = do + > tigerHashUpdate ctx_ key + > tigerHashUpdate ctx_ data0 + > tigerHashUpdate ctx_ data1 + > + > signMessage :: TigerHashable k => k -> Message -> SignedMessage + > signMessage pkey msg = SignedMessage { message = msg, sign = tigerHash (pkey, msg) } + + This is pretty useful when you need to send signed messages over public channel. + + But using this in a such functional way have its drawbacks. Each time system + requires calculation of @hash@ it will issue prepearing of new context for each + calculation instead of using the same context. + + To solve that there is function for processing lazy list: + + > hashMessageSenders :: [Message] -> [(TigerHash, Message)] + > hashMessageSenders msgs = zip (tigerHashList senders) msgs + > where senders = map sender msgs + + This can be used for building hashed storage, which requires hash of each element. + + Notice that while you expand each node of the list 'tigerHashList' will calculate it's @head@ + for you. That's done with intention to loose overhead while hashing files for DC++ . + -} +module Data.Digest.TigerHash (TigerHash, TigerHashable(..), hexTigerHash, b32TigerHash) where +import System.IO.Unsafe +import Foreign.ForeignPtr +import Foreign.Ptr + +import Text.Show +import Data.ByteString.Internal (inlinePerformIO) +import qualified Data.ByteString.Lazy as LBS +import Data.Binary +import Data.Binary.Put +import Data.Binary.Get +import qualified Codec.Binary.Base16 as B16 +import qualified Codec.Binary.Base32 as B32 +import Control.Monad + +import Data.Digest.TigerHash.Internal + +-- | render 'TigerHash' to 'String' as hex-dump +hexTigerHash :: TigerHash -> String +hexTigerHash = B16.encode . LBS.unpack . runPut . put + +-- | render 'TigerHash' to 'String' using Base32 encoding (as used in magnet-links and etc.) +b32TigerHash :: TigerHash -> String +b32TigerHash = B32.encode . LBS.unpack . runPut . put + +instance Show TigerHash where + showsPrec _ th = (++) (b32TigerHash th) + +instance Binary TigerHash where + put (TigerHash a b c) = putWord64host a >> putWord64host b >> putWord64host c + get = do + a <- getWord64host + b <- getWord64host + c <- getWord64host + return (TigerHash a b c) + +class TigerHashable a where + -- | Each 'TigerHashable' data should implement this using 'updateContext' of + -- 'TigerContext' class from "Data.Digest.TigerHash.Internal". But usually + -- there is enough to just call 'tigerHashUpdate' for data which already + -- have instance for 'TigerHashable'. + tigerHashUpdate :: (TigerContext (Ptr c)) => Ptr c -> a -> IO () + + -- | Instant caluculation of Tiger Hash with stack allocated context. + tigerHash :: a -> TigerHash + tigerHash x = inlinePerformIO . withTigerContext $ \ctx -> do + tigerHashUpdate ctx x + finalizeContext ctx + + -- | Same as 'tgerHash', but with Tiger Tree hashing algorithm + tigerTreeHash :: a -> TigerHash + tigerTreeHash x = inlinePerformIO . withTigerTreeContext $ \ctx -> do + tigerHashUpdate ctx x + finalizeContext ctx + + -- | Calculate sequence of hashes where each next is calculated on-demand + -- and /only after previous one/ using one context for all calculations. + -- Be sure to prepare sequence wich contains /only required for hashing/ + -- entries. + tigerHashList :: [a] -> [TigerHash] + tigerHashList [] = [] + tigerHashList (x0:xs) = unsafePerformIO $ do + ctx <- newTigerContext + + let mcomb x mys = unsafeInterleaveIO $ do -- list structure is lazy + y <- withForeignPtr ctx $ \ctx_ -> do + resetContext ctx_ + tigerHashUpdate ctx_ x + finalizeContext ctx_ + liftM (y:) mys + + -- no need to resetContext after newContext + y0 <- withForeignPtr ctx $ \ctx_ -> do + tigerHashUpdate ctx_ x0 + finalizeContext ctx_ + + liftM (y0:) $ foldr mcomb (return []) xs + + {-# NOINLINE tigerHashList #-} + + -- | Same as 'tigerHashList', but with Tiger Tree hashing algorithm + tigerTreeHashList :: [a] -> [TigerHash] + tigerTreeHashList [] = [] + tigerTreeHashList (x0:xs) = unsafePerformIO $ do + ctx <- newTigerTreeContext + + let mcomb x mys = unsafeInterleaveIO $ do -- list structure is lazy + y <- withForeignPtr ctx $ \ctx_ -> do + resetContext ctx_ + tigerHashUpdate ctx_ x + finalizeContext ctx_ + liftM (y:) mys + + -- no need to resetContext after newContext + y0 <- withForeignPtr ctx $ \ctx_ -> do + tigerHashUpdate ctx_ x0 + finalizeContext ctx_ + + liftM (y0:) $ foldr mcomb (return []) xs + + {-# NOINLINE tigerTreeHashList #-} diff --git a/Data/Digest/TigerHash/ByteString.hs b/Data/Digest/TigerHash/ByteString.hs new file mode 100644 --- /dev/null +++ b/Data/Digest/TigerHash/ByteString.hs @@ -0,0 +1,59 @@ +{- + DC++ protocl utls for GHC + Copyright (C) 2009 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + -} + +-- | This module provides nothing, but instances for 'TigerHashable' +module Data.Digest.TigerHash.ByteString () where + + +import Data.Word +import Control.Monad + +import Foreign.Ptr +import Foreign.ForeignPtr + +import qualified Data.ByteString.Internal as S +import qualified Data.ByteString.Lazy.Internal as L +import qualified Data.ByteString.Lazy as LBS + + +import Data.Digest.TigerHash +import qualified Data.Digest.TigerHash.Internal as T + +instance TigerHashable S.ByteString where + tigerHashUpdate ctx = updateBS . S.toForeignPtr where + updateBS (_, _, 0) = return () + updateBS (p, s, l) = withForeignPtr p $ \p_ -> T.updateContext ctx (p_ `plusPtr` s) l + {-# INLINE updateBS #-} + {-# INLINE tigerHashUpdate #-} + +instance TigerHashable L.ByteString where + tigerHashUpdate ctx lbs = L.foldrChunks ((>>) . tigerHashUpdate ctx) (return ()) lbs + {-# INLINE tigerHashUpdate #-} + +instance TigerHashable [Word8] where + tigerHashUpdate ctx = tigerHashUpdate ctx . LBS.pack + {-# INLINE tigerHashUpdate #-} + + tigerHash = tigerHash . LBS.pack + {-# INLINE tigerHash #-} + + tigerHashList = tigerHashList . map LBS.pack + {-# INLINE tigerHashList #-} + diff --git a/Data/Digest/TigerHash/Internal.hs b/Data/Digest/TigerHash/Internal.hs new file mode 100644 --- /dev/null +++ b/Data/Digest/TigerHash/Internal.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE ForeignFunctionInterface,FlexibleInstances #-} +{-# LANGUAGE EmptyDataDecls #-} +{- + DC++ protocl utls for GHC + Copyright (C) 2009 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + -} + +module Data.Digest.TigerHash.Internal ( + TigerHash(..), TigerContext(..), TigerState, TigerTreeState, + newTigerContext, + newTigerTreeContext, + withTigerContext, withTigerTreeContext, + ) where + +import Foreign +import Foreign.Ptr +import Foreign.ForeignPtr +import Foreign.Marshal.Alloc +import Foreign.Marshal.Array +import Foreign.C.Types + +data TigerHash = TigerHash {-# UNPACK #-} !Word64 + {-# UNPACK #-} !Word64 + {-# UNPACK #-} !Word64 + + +-- Level 1 + +class TigerContext c where + initContext :: c -> IO () + updateContext :: c -> Ptr a -> Int -> IO () + resetContext :: c -> IO () + finalizeContext :: c -> IO TigerHash + +newTigerContext :: IO (ForeignPtr TigerState) +newTigerContext = do + ctx <- mallocBytes sizeofTigerContext >>= newForeignPtr finalizerFree + initContext ctx + return ctx + +newTigerTreeContext :: IO (ForeignPtr TigerTreeState) +newTigerTreeContext = do + ctx <- mallocBytes sizeofTigerTreeContext >>= newForeignPtr finalizerFree + initContext ctx + return ctx + +withTigerContext :: (Ptr TigerState -> IO a) -> IO a +withTigerContext actions = allocaBytes sizeofTigerContext (\ctx_ -> initContext ctx_ >> actions ctx_) + +withTigerTreeContext :: (Ptr TigerTreeState -> IO a) -> IO a +withTigerTreeContext actions = allocaBytes sizeofTigerTreeContext (\ctx_ -> initContext ctx_ >> actions ctx_) + +instance TigerContext (Ptr TigerState) where + initContext ctx_ = initTigerContext_ ctx_ + updateContext ctx_ p_ s = updateTigerContext_ ctx_ p_ (fromIntegral s) + resetContext ctx_ = resetTigerContext_ ctx_ + finalizeContext ctx_ = allocaArray 3 internal + where + internal p_ = do + finalizeTigerContext_ ctx_ p_ + a <- peekElemOff p_ 0 + b <- peekElemOff p_ 1 + c <- peekElemOff p_ 2 + return (TigerHash a b c) + +instance TigerContext (Ptr TigerTreeState) where + initContext ctx_ = initTigerTreeContext_ ctx_ + updateContext ctx_ p_ s = updateTigerTreeContext_ ctx_ p_ (fromIntegral s) + resetContext ctx_ = resetTigerTreeContext_ ctx_ + finalizeContext ctx_ = allocaArray 3 internal + where + internal p_ = do + finalizeTigerTreeContext_ ctx_ p_ + a <- peekElemOff p_ 0 + b <- peekElemOff p_ 1 + c <- peekElemOff p_ 2 + return (TigerHash a b c) + +instance (TigerContext (Ptr a)) => TigerContext (ForeignPtr a) where + initContext ctx = withForeignPtr ctx initContext + updateContext ctx p_ s = withForeignPtr ctx (\ctx_ -> updateContext ctx_ p_ s) + resetContext ctx = withForeignPtr ctx resetContext + finalizeContext ctx = withForeignPtr ctx finalizeContext + + +-- Level 0 + +data TigerState +data TigerTreeState + +{-# CFILES c_lib/tiger.c #-} + +foreign import ccall unsafe "tiger.h tiger_context_size" sizeofTigerContext :: Int +foreign import ccall unsafe "tiger.h tiger_init" initTigerContext_ :: Ptr TigerState -> IO () +-- foreign import ccall unsafe "tiger.h tiger_new" newTigerContext_ :: IO (Ptr TigerState) +-- foreign import ccall unsafe "tiger.h &tiger_free" freeTigerContext_ :: FinalizerPtr TigerState + +foreign import ccall unsafe "tiger.h tiger_feed" updateTigerContext_ :: Ptr TigerState -> Ptr a -> CSize -> IO () +foreign import ccall unsafe "tiger.h tiger_finalize" finalizeTigerContext_ :: Ptr TigerState -> Ptr Word64 -> IO () +foreign import ccall unsafe "tiger.h tiger_reset" resetTigerContext_ :: Ptr TigerState -> IO () + +{-# CFILES c_lib/tigertree.c #-} + +foreign import ccall unsafe "tigertree.h tigertree_context_size" sizeofTigerTreeContext :: Int +foreign import ccall unsafe "tigertree.h tigertree_init" initTigerTreeContext_ :: Ptr TigerTreeState -> IO () +-- foreign import ccall unsafe "tigertree.h tigertree_new" newTigerTreeContext_ :: IO (Ptr TigerTreeState) +-- foreign import ccall unsafe "tigertree.h &tigertree_free" freeTigerTreeContext_ :: FinalizerPtr TigerTreeState + +foreign import ccall unsafe "tigertree.h tigertree_feed" updateTigerTreeContext_ :: Ptr TigerTreeState -> Ptr a -> CSize -> IO () +foreign import ccall unsafe "tigertree.h tigertree_finalize" finalizeTigerTreeContext_ :: Ptr TigerTreeState -> Ptr Word64 -> IO () +foreign import ccall unsafe "tigertree.h tigertree_reset" resetTigerTreeContext_ :: Ptr TigerTreeState -> IO () + +-- ex:syntax=haskell diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +#!/usr/bin/env runhaskell +import Distribution.Simple +main = defaultMain diff --git a/TigerHash.cabal b/TigerHash.cabal new file mode 100644 --- /dev/null +++ b/TigerHash.cabal @@ -0,0 +1,83 @@ +-- TigerHash.cabal auto-generated by cabal init. For additional +-- options, see +-- http://www.haskell.org/cabal/release/cabal-latest/doc/users-guide/authors.html#pkg-descr. +-- The name of the package. +Name: TigerHash + +-- The package version. See the Haskell package versioning policy +-- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for +-- standards guiding when and how versions should be incremented. +Version: 0.2 + +-- A short (one-line) description of the package. +Synopsis: TigerHash with C implementation + +-- A longer description of the package. +Description: + This library provides Tiger Hash algorithm implemented in C + and built with Haskell interface. As well there is implementation + of Merkle Tree known as TTH (Tiger Tree Hash). + + +-- The license under which the package is released. +License: GPL-2 + +-- The file containing the license text. +License-file: LICENSE + +-- The package author(s). +Author: Nikolay Orlyuk + +-- An email address to which users can send suggestions, bug reports, +-- and patches. +Maintainer: virkony@gmail.com + +-- A copyright notice. +Copyright: (c) 2010 Nikolay Orlyuk + +-- Stability of the pakcage (experimental, provisional, stable...) +Stability: Provisional + +Category: Cryptography + +Build-type: Simple + +-- Extra files to be distributed with the package, such as examples or +-- a README. +Extra-source-files: + test-vectors-nessie-format.dat + examples/hasher.hs + examples/testtiger.hs + +-- Constraint on the version of Cabal needed to build this package. +Cabal-version: >=1.4 + +Library + -- Modules exported by the library. + Exposed-modules: + Data.Digest.TigerHash + Data.Digest.TigerHash.ByteString + Data.Digest.TigerHash.Internal + + -- Packages needed in order to build this package. + Build-depends: base >= 4 && < 5,bytestring,binary,dataenc + + Extensions: ForeignFunctionInterface,EmptyDataDecls,FlexibleInstances,FlexibleContexts,UndecidableInstances + + Include-Dirs: c_lib + Install-Includes: tiger.h + tigertree.h + C-Sources: c_lib/tiger.c + c_lib/tigertree.c + + + GHC-Options: -Wall -fno-warn-orphans + CPP-Options: -DNDEBUG + CC-Options: -DNDEBUG + + -- Modules not exported by this package. + -- Other-modules: + + -- Extra tools (e.g. alex, hsc2hs, ...) needed to build the source. + -- Build-tools: + diff --git a/c_lib/tiger.c b/c_lib/tiger.c new file mode 100644 --- /dev/null +++ b/c_lib/tiger.c @@ -0,0 +1,843 @@ +/* + * Copyright (C) 2001-2006 Jacek Sieka, arnetheduck on gmail point com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +/* + DC++ protocl utls for GHC + Copyright (C) 2009 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +#include +#include +#include +#include + +#include "tiger.h" + +#if defined(__GNUC__) +#define _ULL(c) ((uint64_t)(c ## ULL)) +#else +#define _ULL(c) (c ## ui64) +#endif + + +#ifdef _WIN32 +#if defined(_M_X64) +#define TIGER_ARCH64 +#endif +#if !(defined(_M_IX86) || defined(_M_X64)) +#define TIGER_BIG_ENDIAN +#endif +#else /* _WIN32 */ +#if defined(__x86_64__) || defined(__alpha) +#define TIGER_ARCH64 +#endif +#if !(defined(__i386__) || defined(__x86_64__) || defined(__alpha)) +#define TIGER_BIG_ENDIAN +#endif +#endif /* _WIN32 */ + +#define PASSES 3 + +#define t1 (table) +#define t2 (table+256) +#define t3 (table+256*2) +#define t4 (table+256*3) + +#define save_abc \ + aa = a; \ + bb = b; \ + cc = c; + +#ifdef TIGER_ARCH64 +#define round(a,b,c,x,mul) \ + c ^= x; \ + a -= t1[((c)>>(0*8))&0xFF] ^ t2[((c)>>(2*8))&0xFF] ^ \ + t3[((c)>>(4*8))&0xFF] ^ t4[((c)>>(6*8))&0xFF] ; \ + b += t4[((c)>>(1*8))&0xFF] ^ t3[((c)>>(3*8))&0xFF] ^ \ + t2[((c)>>(5*8))&0xFF] ^ t1[((c)>>(7*8))&0xFF] ; \ + b *= mul; +#else +#define round(a,b,c,x,mul) \ + c ^= x; \ + a -= t1[(uint8_t)(c)] ^ \ + t2[(uint8_t)(((uint32_t)(c))>>(2*8))] ^ \ + t3[(uint8_t)((c)>>(4*8))] ^ \ + t4[(uint8_t)(((uint32_t)((c)>>(4*8)))>>(2*8))] ; \ + b += t4[(uint8_t)(((uint32_t)(c))>>(1*8))] ^ \ + t3[(uint8_t)(((uint32_t)(c))>>(3*8))] ^ \ + t2[(uint8_t)(((uint32_t)((c)>>(4*8)))>>(1*8))] ^ \ + t1[(uint8_t)(((uint32_t)((c)>>(4*8)))>>(3*8))]; \ + b *= mul; +#endif + +#define pass(a,b,c,mul) \ + round(a,b,c,x0,mul) \ + round(b,c,a,x1,mul) \ + round(c,a,b,x2,mul) \ + round(a,b,c,x3,mul) \ + round(b,c,a,x4,mul) \ + round(c,a,b,x5,mul) \ + round(a,b,c,x6,mul) \ + round(b,c,a,x7,mul) + +#define key_schedule \ + x0 -= x7 ^ _ULL(0xA5A5A5A5A5A5A5A5); \ + x1 ^= x0; \ + x2 += x1; \ + x3 -= x2 ^ ((~x1)<<19); \ + x4 ^= x3; \ + x5 += x4; \ + x6 -= x5 ^ ((~x4)>>23); \ + x7 ^= x6; \ + x0 += x7; \ + x1 -= x0 ^ ((~x7)<<19); \ + x2 ^= x1; \ + x3 += x2; \ + x4 -= x3 ^ ((~x2)>>23); \ + x5 ^= x4; \ + x6 += x5; \ + x7 -= x6 ^ _ULL(0x0123456789ABCDEF); + +#define feedforward \ + a ^= aa; \ + b -= bb; \ + c += cc; + +#ifdef TIGER_ARCH64 +#define compress \ + save_abc \ + pass(a,b,c,5) \ + key_schedule \ + pass(c,a,b,7) \ + key_schedule \ + pass(b,c,a,9) \ + for(pass_no=3; pass_nobytes = _ULL(0), + ctx->a = INIT_A, + ctx->b = INIT_B, + ctx->c = INIT_C; +} + +void tiger_free(tiger_context *ctx) { + return free(ctx); +} + +static inline const uint64_t bswap_64(const uint64_t x) +{ + /* [0,8,16,24,32,40,48,56] */ + return ( + ((x & _ULL(0xff00000000000000)) >> 56) | + ((x & _ULL(0x00ff000000000000)) >> 40) | + ((x & _ULL(0x0000ff0000000000)) >> 24) | + ((x & _ULL(0x000000ff00000000)) >> 8) | + ((x & _ULL(0x00000000ff000000)) << 8) | + ((x & _ULL(0x0000000000ff0000)) << 24) | + ((x & _ULL(0x000000000000ff00)) << 40) | + ((x & _ULL(0x00000000000000ff)) << 56) + ); +} + +void tiger_feed(tiger_context *ctx, const void *block, size_t bytes_count) +{ + const size_t pending_bytes = ctx->bytes % TIGER_BLOCK_SIZE; +#ifdef TIGER_BIG_ENDIAN + size_t i; +#endif + + //assert( !(bits_count % 8) || !"implemented yet" ); + + if ((pending_bytes > 0) || (bytes_count < TIGER_BLOCK_SIZE)) { + const size_t align_bytes = TIGER_BLOCK_SIZE-pending_bytes; + if (align_bytes > bytes_count) { + memcpy(ctx->pending.bytes + pending_bytes, block, bytes_count); + ctx->bytes += bytes_count; + return; + } + memcpy(ctx->pending.bytes + pending_bytes, block, align_bytes); + ctx->bytes += align_bytes, + block = (const uint8_t*)block + align_bytes, + bytes_count -= align_bytes; +#ifdef TIGER_BIG_ENDIAN + for(i=0;ipending.words[i] = bswap_64(ctx->pending.words[i]); +#endif + tiger_compress_macro(ctx->pending.words, ctx->a, ctx->b, ctx->c); + } + + ctx->bytes += bytes_count; + + while( bytes_count >= TIGER_BLOCK_SIZE ) { +#ifdef TIGER_BIG_ENDIAN + for(i=0;ipending.bytes[i^7] = ((const uint8_t*)block)[i]; + tiger_compress_macro(ctx->pending.words, ctx->a, ctx->b, ctx->c); +#else + tiger_compress_macro((const uint64_t*)block, ctx->a, ctx->b, ctx->c); +#endif + block = (const uint8_t*)block + TIGER_BLOCK_SIZE, + bytes_count -= TIGER_BLOCK_SIZE; + } + + memcpy(ctx->pending.bytes, block, bytes_count); +} + +void tiger_finalize(tiger_context *ctx, void *hash) { + const size_t pending_bytes = ctx->bytes % TIGER_BLOCK_SIZE; + uint64_t * const res = hash; + + res[0] = ctx->a, + res[1] = ctx->b, + res[2] = ctx->c; + +#ifndef TIGER_BIG_ENDIAN + /* inplace */ + if( (pending_bytes + 1 + 8) < TIGER_BLOCK_SIZE) { + ctx->pending.bytes[pending_bytes] = 0x01; + memset(ctx->pending.bytes + pending_bytes + 1, 0, TIGER_BLOCK_SIZE - pending_bytes - 1); + ctx->pending.words[7] = ctx->bytes * 8; + tiger_compress_macro(ctx->pending.words, res[0], res[1], res[2]); + } else +#endif + { + union { + uint64_t words[TIGER_BLOCK_WSIZE]; + uint8_t bytes[TIGER_BLOCK_SIZE]; + } buf; +#ifdef TIGER_BIG_ENDIAN + size_t i; +#endif + memcpy(buf.bytes, ctx->pending.bytes, pending_bytes); + buf.bytes[pending_bytes] = 0x01; + memset(buf.bytes + pending_bytes + 1, 0, TIGER_BLOCK_SIZE - pending_bytes - 1); + if ((pending_bytes + 1 + 8) > TIGER_BLOCK_SIZE) { +#ifdef TIGER_BIG_ENDIAN + for(i=0;ibytes*8; +#ifdef TIGER_BIG_ENDIAN + for(i=0;i + +#define TIGER_HASH_BITS (3*64) +#define TIGER_HASH_SIZE (TIGER_HASH_BITS/8) + +struct tiger_context_s; +typedef struct tiger_context_s tiger_context; + +#ifdef __cplusplus +extern "C" { +#endif + +tiger_context *tiger_new(); +void tiger_init(tiger_context *ctx); +void tiger_reset(tiger_context *ctx); +void tiger_free(tiger_context *ctx); +void tiger_feed(tiger_context *ctx, const void *block, size_t bytes_count); +void tiger_finalize(tiger_context *ctx, void *hash); + +const size_t tiger_context_size(); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/c_lib/tigertree.c b/c_lib/tigertree.c new file mode 100644 --- /dev/null +++ b/c_lib/tigertree.c @@ -0,0 +1,241 @@ +/* + * Copyright (C) 2010 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +/* + DC++ protocl utls for GHC + Copyright (C) 2010 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +#include +#include + +#include "tiger.h" +#include "tigertree.h" + +typedef struct tigertree_stack_s { + char buf[1+2*TIGER_HASH_SIZE]; /* first byte shows: 00 - empty, 01 - half */ + struct tigertree_stack_s *upper; +} tigertree_stack; + +typedef struct tigertree_allocs_s { + tigertree_stack data[6]; /* (19+6) => 32 GB, (19+6+6) => 2 TB, so I wouldn't expect more than 2 allocs */ + struct tigertree_allocs_s *prev; +} tigertree_allocs; + +struct tigertree_context_s { + size_t left; + + tiger_context *tiger; + + unsigned int level; + tigertree_stack *bottom, *top; + tigertree_allocs *allocs; + + tigertree_stack stack[19]; /* 19 => 512 MB, should be enough for many files */ +}; + +const size_t tigertree_context_size() { return sizeof(struct tigertree_context_s); } + + +static void tigertree_format_alloc(tigertree_stack *data, const size_t cnt, tigertree_stack *top) +{ + size_t i; + + if (top != NULL) top->upper = data+0; + + /* format allocated levels by linking them each with other */ + for(i=1;idata; + const size_t cnt = sizeof(next->data)/sizeof(data[0]); + + if (ctx->allocs != NULL) { + assert( ctx->allocs->data[cnt-1].upper == NULL ); + next->prev = ctx->allocs; + } + else next->prev = NULL; + + tigertree_format_alloc(data, cnt, ctx->top); + ctx->top = data + cnt-1; + ctx->allocs = next; + + return data; +} + +void tigertree_init(tigertree_context *ctx) +{ + const size_t cnt = sizeof(ctx->stack) / sizeof(ctx->stack[0]); + ctx->tiger = tiger_new(); + tiger_feed(ctx->tiger, "\0", 1); + + ctx->left = TIGERTREE_BLOCK_SIZE; + + ctx->level = 0; + ctx->allocs = NULL; + + tigertree_format_alloc(ctx->stack, cnt, NULL); + ctx->top = ctx->stack + cnt-1; + ctx->bottom = ctx->stack + 0; /* atleast one level */ +} + +void tigertree_done(tigertree_context *ctx) +{ + tigertree_allocs *f = ctx->allocs; + while(f != NULL) { + tigertree_allocs * const u = f->prev; + free(f); + f = u; + } + + tiger_free(ctx->tiger); +} + + +static void tigertree_feed_leaf(tigertree_context *ctx) +{ + const unsigned int clevel = ctx->level; + unsigned int level = 1; + tigertree_stack *node = ctx->bottom; + assert( ctx->bottom != NULL ); + + + while((node->buf[0] == '\1') && (level <= clevel)) { /* carry up */ + tiger_finalize(ctx->tiger, node->buf + 1 + TIGER_HASH_SIZE); + + tiger_reset(ctx->tiger); + tiger_feed(ctx->tiger, node->buf, 1 + 2*TIGER_HASH_SIZE); + node->buf[0] = '\0'; /* clear up this node */ + + /* now we have new hash to finalize in our ctx */ + node = node->upper; + if (node == NULL ) { + node = tigertree_alloc(ctx); + ++level; + break; + } + else if ((++level) > clevel) break; /* we've reached the top */ + } + + if (level > clevel) ctx->level = level; + + node->buf[0] = '\1'; + return tiger_finalize(ctx->tiger, node->buf + 1); +} + +void tigertree_feed(tigertree_context *ctx, const void *buf, size_t len) +{ + const char *p = buf; + + while(1) { + if (len < ctx->left) { + ctx->left -= len; + return tiger_feed(ctx->tiger, p, len); + } + tiger_feed(ctx->tiger, p, ctx->left); + tigertree_feed_leaf(ctx); + + tiger_reset(ctx->tiger); + tiger_feed(ctx->tiger, "\0", 1); + + p += ctx->left; + len -= ctx->left; + ctx->left = TIGERTREE_BLOCK_SIZE; + } +} + +void tigertree_finalize(tigertree_context *ctx, void *hash) +{ + if ((ctx->left < TIGERTREE_BLOCK_SIZE) || /* last block */ + (ctx->level == 0)) /* finalize for empty file (no leafs were added) */ + tigertree_feed_leaf(ctx); + tiger_reset(ctx->tiger); + + { + const size_t clevel = ctx->level; + size_t level; + tigertree_stack *node = ctx->bottom; + const void *rhash = NULL; + + assert( ctx->level > 0 ); + + for(level = 1; level <= clevel; ++level, node = node->upper) { + assert( node != NULL ); + + if (node->buf[0] == '\0') continue; + assert( node->buf[0] == '\1' ); + + if (rhash == NULL) { + rhash = node->buf+1; + continue; + } + + tiger_feed(ctx->tiger, node->buf, 1+TIGER_HASH_SIZE); + tiger_feed(ctx->tiger, rhash, TIGER_HASH_SIZE); + tiger_finalize(ctx->tiger, hash); + tiger_reset(ctx->tiger); + rhash = hash; + } + + if (rhash != hash) memcpy(hash, rhash, TIGER_HASH_SIZE); + } +} + +void tigertree_reset(tigertree_context *ctx) +{ + tiger_reset(ctx->tiger); + tiger_feed(ctx->tiger, "\0", 1); + + ctx->left = TIGERTREE_BLOCK_SIZE; + + ctx->level = 0; /* will cut carrying up and force use next node (bottom) as empty */ +} + +tigertree_context *tigertree_new() +{ + tigertree_context *ctx = (tigertree_context*)malloc(sizeof(tigertree_context)); + tigertree_init(ctx); + return ctx; +} + +void tigertree_free(tigertree_context *ctx) +{ + tigertree_done(ctx); + free(ctx); +} diff --git a/c_lib/tigertree.h b/c_lib/tigertree.h new file mode 100644 --- /dev/null +++ b/c_lib/tigertree.h @@ -0,0 +1,48 @@ +/* + DC++ protocl utls for GHC + Copyright (C) 2009 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +#ifndef __tigertree_h__ +#define __tigertree_h__ + +#include + +typedef struct tigertree_context_s tigertree_context; + +#define TIGERTREE_BLOCK_SIZE 1024 + +#ifdef __cplusplus +extern "C" { +#endif + +void tigertree_init(tigertree_context *ctx); +void tigertree_done(tigertree_context *ctx); +void tigertree_feed(tigertree_context *ctx, const void *block, size_t bytes_count); +void tigertree_finalize(tigertree_context *ctx, void *hash); +void tigertree_reset(tigertree_context *ctx); + +const size_t tigertree_context_size(); +tigertree_context *tigertree_new(); +void tigertree_free(tigertree_context *ctx); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/examples/hasher.hs b/examples/hasher.hs new file mode 100644 --- /dev/null +++ b/examples/hasher.hs @@ -0,0 +1,69 @@ +{- + DC++ protocl utls for GHC + Copyright (C) 2009 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + -} + +import Text.Show +import Data.List +import Data.Word +import Data.Bits + +import qualified Data.ByteString.Lazy as B + +import Control.Monad +import Control.Arrow + +import System +import System.IO +import System.IO.Unsafe +import System.Directory +import System.FilePath +import Data.List.Stream () + +import Data.Digest.TigerHash +import Data.Digest.TigerHash.ByteString () + +showsHash :: String -> TigerHash -> ShowS +showsHash desc th = shows th . showChar ' ' . showString desc . showChar '\n' + +traverse path = unsafeInterleaveIO $ do + nodes <- liftM (map (path ) . filter (`notElem` [".",".."])) $ getDirectoryContents path + files <- filterM (unsafeInterleaveIO . doesFileExist) nodes + subdirs <- filterM (unsafeInterleaveIO . doesDirectoryExist) nodes + liftM ((files ++) . concat) . unsafeInterleaveIO $ mapM traverse subdirs + +hash fn = B.readFile fn >>= putStr . flip (showsHash fn) [] . tigerTreeHash + +main_args :: [String] -> IO () +main_args [] = main_args ["-"] +main_args ["-"] = B.getContents >>= putStr . flip (showsHash "-") [] . tigerTreeHash +main_args args = do + --process args + filenamesA <- filterM (unsafeInterleaveIO . doesFileExist) args + let dirnames = filter (`notElem` filenamesA) args + filenamesB <- liftM concat $ mapM traverse dirnames + let filenames = filenamesA ++ filenamesB + + let printHash fn hash = putStr $ showsHash fn hash [] + let readFn fn = return . (,) fn =<< unsafeInterleaveIO (B.readFile fn) + contents <- mapM (readFn) filenames + let hashes = uncurry zip (second tigerTreeHashList $ unzip contents) + mapM_ (uncurry printHash) hashes + + +main = getArgs >>= main_args . nub diff --git a/examples/testtiger.hs b/examples/testtiger.hs new file mode 100644 --- /dev/null +++ b/examples/testtiger.hs @@ -0,0 +1,97 @@ +{- + DC++ protocl utls for GHC + Copyright (C) 2009 Nikolay Orlyuk (virkony _at_ gmail _dot_ com) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + -} + +{-# OPTIONS_GHC -O2 -fignore-asserts -fspec-constr #-} + +import Data.Digest.TigerHash +import Data.Digest.TigerHash.ByteString +import Data.Digest.TigerHash.Internal + +import Text.Printf + +import Data.Word +import Data.Bits +import qualified Data.ByteString as B +import qualified Data.ByteString.Internal as S +import qualified Data.ByteString.Char8 as BC +import Foreign.Ptr +import Foreign.ForeignPtr + +import Control.Monad + +import System.Posix.Process + +iterations = 200000::Word32 + +explodeBytes :: (Integral n, Bits n) => n -> [Word8] +explodeBytes x = walk (bitSize x `div` 8) x where + walk 0 _ = [] + walk p x = (fromIntegral x : walk (p-1) (x `shiftR` 8)) + +hash s = do + let th = tigerHash (BC.pack s) + putStr $ "Hash of \"" ++ s ++ "\":\n\t" ++ hexTigerHash th ++ "\n" + +main = do + -- Hash of short strings + hash "" + hash "abc" + hash "Tiger" + -- Hash of 512-bit strings + hash "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-" + hash "ABCDEFGHIJKLMNOPQRSTUVWXYZ=abcdefghijklmnopqrstuvwxyz+0123456789" + hash "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham" + -- Hash of two-block strings strings + hash "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge." + hash "Tiger - A Fast New Hash Function, by Ross Anderson and Eli Biham, proceedings of Fast Software Encryption 3, Cambridge, 1996." + hash "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-" + + -- Hash of a 64K byte string + let buffer = B.pack [fromIntegral i | i <- [0 .. 65535]] + buffer `seq` return () -- force calc + + let th = tigerHash buffer + putStr $ "Hash of a 64K-byte string:\n\t" ++ hexTigerHash th ++ "\n" + + putStr "Calculating speed...\n" + + t1 <- getProcessTimes + + let (p, s, bufSz) = S.toForeignPtr buffer in withForeignPtr p $ \p_ -> do + let bufPtr = (p_ `plusPtr` s) + withTigerContext $ \ctx_ -> do + let body = do + resetContext ctx_ + updateContext ctx_ bufPtr bufSz + finalizeContext ctx_ + mapM_ (const body) [1 .. fromIntegral iterations] + + t2 <- getProcessTimes + + let rate = fromIntegral iterations * fromIntegral (B.length buffer) * 8 / toRational (userTime t2 - userTime t1) + let humanRate = walk ["bit","KBit", "MBit", "GBit", "TBit"] where + walk [x] r = (r, x) + walk (x:xs) r | r < 512 = (r, x) + | otherwise = walk xs (r / 1024) + + let (hRate,hSym) = humanRate rate + printf "rate = %.3f %s/s\n" ((fromRational hRate)::Double) hSym + + diff --git a/test-vectors-nessie-format.dat b/test-vectors-nessie-format.dat new file mode 100644 --- /dev/null +++ b/test-vectors-nessie-format.dat @@ -0,0 +1,6212 @@ +******************************************************************************** +*Project NESSIE - New European Schemes for Signature, Integrity, and Encryption* +******************************************************************************** + +Primitive Name: Tiger +===================== +Hash size: 192 bits + +Test vectors -- set 1 +===================== + +Set 1, vector# 0: + message="" (empty string) + hash=3293AC630C13F0245F92BBB1766E16167A4E58492DDE73F3 + +Set 1, vector# 1: + message="a" + hash=77BEFBEF2E7EF8AB2EC8F93BF587A7FC613E247F5F247809 + +Set 1, vector# 2: + message="abc" + hash=2AAB1484E8C158F2BFB8C5FF41B57A525129131C957B5F93 + +Set 1, vector# 3: + message="message digest" + hash=D981F8CB78201A950DCF3048751E441C517FCA1AA55A29F6 + +Set 1, vector# 4: + message="abcdefghijklmnopqrstuvwxyz" + hash=1714A472EEE57D30040412BFCC55032A0B11602FF37BEEE9 + +Set 1, vector# 5: + message="abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" + hash=0F7BF9A19B9C58F2B7610DF7E84F0AC3A71C631E7B53F78E + +Set 1, vector# 6: + message="A...Za...z0...9" + hash=8DCEA680A17583EE502BA38A3C368651890FFBCCDC49A8CC + +Set 1, vector# 7: + message=8 times "1234567890" + hash=1C14795529FD9F207A958F84C52F11E887FA0CABDFD91BFD + +Set 1, vector# 8: + message=1 million times "a" + hash=6DB0E2729CBEAD93D715C6A7D36302E9B3CEE0D2BC314B41 + +Test vectors -- set 2 +===================== +Message digests of strings of 0-bits and variable length: + +Set 2, vector# 0: + message=0 zero bits + hash=3293AC630C13F0245F92BBB1766E16167A4E58492DDE73F3 + +Set 2, vector# 1: + message=1 zero bits + hash=766AFA25B4C4D82C835B8320654C93BDAC3BA9671A0C83AA + +Set 2, vector# 2: + message=2 zero bits + hash=C2A72A4D6B22A5CD2750DD772F28F809CC15D40D552A2129 + +Set 2, vector# 3: + message=3 zero bits + hash=6C36DECB7CACFD5D87737515E25C79AE4D545CD487DE9CE5 + +Set 2, vector# 4: + message=4 zero bits + hash=CA3BE46BB668F8A7D60349A2931D17D53BB55F354BD985A6 + +Set 2, vector# 5: + message=5 zero bits + hash=46B9C0183B22D60ABE0DCB6A20D1B4632C2D918D32007C66 + +Set 2, vector# 6: + message=6 zero bits + hash=3B8A19B192E7559413F577C112B7515A2932BEACFB994432 + +Set 2, vector# 7: + message=7 zero bits + hash=06AA7ABCE8443EDBB4B583D7E273E95CA7883CD2E11606C4 + +Set 2, vector# 8: + message=8 zero bits + hash=5D9ED00A030E638BDB753A6A24FB900E5A63B8E73E6C25B6 + +Set 2, vector# 9: + message=9 zero bits + hash=ADA18985026A8D65B9819B2292C587CBB3D88435CF92ECE9 + +Set 2, vector# 10: + message=10 zero bits + hash=4C2B2A626E9D8089A49F4584070BD42D1C14B7610A2DFBFE + +Set 2, vector# 11: + message=11 zero bits + hash=59065CD74C36A450CAEA0A367B32EE17F189820661086DEE + +Set 2, vector# 12: + message=12 zero bits + hash=BFE432C13F794D4BB51E4340F2E2272E4D052F75404608A2 + +Set 2, vector# 13: + message=13 zero bits + hash=6C90EABF3F9B8F9C2A998A5EF0F7B739D7ED088FF7108326 + +Set 2, vector# 14: + message=14 zero bits + hash=CC7BA5FBB401A8F3A4E503C854AE6D2AAD250DC3869B6805 + +Set 2, vector# 15: + message=15 zero bits + hash=52C9CA4CF1ADB66993BB63979B437FE2DB32F3A7E6FA07E6 + +Set 2, vector# 16: + message=16 zero bits + hash=AABBCCA084ACECD0511D1F6232A17BFAEFA441B2982E5548 + +Set 2, vector# 17: + message=17 zero bits + hash=E3DC5C51C3BD9C5DB89C31785CEE78E84342BFDAA771986E + +Set 2, vector# 18: + message=18 zero bits + hash=41613E1EE815D8C9AF5C3EA7CE2C5D55A2D6D76D6C739900 + +Set 2, vector# 19: + message=19 zero bits + hash=1B8575786EB7F87DDC2AE148FA2E28D55074F7B4F98E65E7 + +Set 2, vector# 20: + message=20 zero bits + hash=F963FA72706F3FF0F55CD2B36211A06CD190E149E53D9BF4 + +Set 2, vector# 21: + message=21 zero bits + hash=BAF5E11ACDE2EB6807403BD0012923775498D9B0C6ADB629 + +Set 2, vector# 22: + message=22 zero bits + hash=9272B22055528CCC9AB3EDC772D12976BAAF65768F000CBA + +Set 2, vector# 23: + message=23 zero bits + hash=7D6FC776F1055B15D803D9EF6DD5C6101557BF0381C0C28A + +Set 2, vector# 24: + message=24 zero bits + hash=7F7A8CE9580077EB6FD53BE8BB3E70650E2FDD8DBB44F5C7 + +Set 2, vector# 25: + message=25 zero bits + hash=6315472E27E41795BB61E560E552ABA13B35A6D1F2E9ECA7 + +Set 2, vector# 26: + message=26 zero bits + hash=CFB8F014B109374B249DA192EEFCE83AC7E3F40FD5317C7A + +Set 2, vector# 27: + message=27 zero bits + hash=663AC22F5301AD1EF6EA81DF1730A95EAD03188D7E9464E4 + +Set 2, vector# 28: + message=28 zero bits + hash=9E657C65CE849AD1F50E8558AB1490A09713A408CD595126 + +Set 2, vector# 29: + message=29 zero bits + hash=0DBFC4A6203B362AA084480CC9848901CE13B7054F805484 + +Set 2, vector# 30: + message=30 zero bits + hash=3AE28B4517A2D8689127C3BA107E633F39F37F9D7CDB75EF + +Set 2, vector# 31: + message=31 zero bits + hash=8C81474D9940F5410161BF3902C738888FEA5CB4873449D4 + +Set 2, vector# 32: + message=32 zero bits + hash=605D1B8C132BF5D16F1A8BC2451733F7F0FF57FD5F49E298 + +Set 2, vector# 33: + message=33 zero bits + hash=B2A6F45A6AAE093014855774713C5D270A6982331B7018F6 + +Set 2, vector# 34: + message=34 zero bits + hash=A08FBD9D743A063E1FD2F3061C7DEC96BC4A09AC2BA34273 + +Set 2, vector# 35: + message=35 zero bits + hash=89B2467A13BE3A4ACE341061935F2359BFB9CC96BCE752DC + +Set 2, vector# 36: + message=36 zero bits + hash=8DD0EBEA7F94294E614660782762A18F37A2931769551D73 + +Set 2, vector# 37: + message=37 zero bits + hash=CAD18FF3B396F7FB04EE33C56BCA3FC3436040628D7989CC + +Set 2, vector# 38: + message=38 zero bits + hash=F69C7F27A572E6653C782B6E1BB5146BA4C8A800D2CBBDB1 + +Set 2, vector# 39: + message=39 zero bits + hash=230B9F3B0BA4459990698ED7519B5D42B3234B4315F0EFB0 + +Set 2, vector# 40: + message=40 zero bits + hash=7F3A0954A5C374566C72370D1D97C2AC8FA9B1E3CB216E31 + +Set 2, vector# 41: + message=41 zero bits + hash=A80CED7C0EE0898C340FD366179019B66654212301221945 + +Set 2, vector# 42: + message=42 zero bits + hash=3A072F0455BACEB53763EDDB3D76EB867C29D7F89D180682 + +Set 2, vector# 43: + message=43 zero bits + hash=004717AC7E1FCBFD3C804ECE8FD228FB44C48179BB5232F7 + +Set 2, vector# 44: + message=44 zero bits + hash=AAC53D160368ACF2E74D962F45F3C8D70559338B5D6DB241 + +Set 2, vector# 45: + message=45 zero bits + hash=C39DD9C707D2812831C4DFC57C98F99ED5BDDB5A6136AEA8 + +Set 2, vector# 46: + message=46 zero bits + hash=7278E1FC893D215B384AD47A99CC1B678A647A2D04BA6647 + +Set 2, vector# 47: + message=47 zero bits + hash=C6F774270ECA51112046E06A8E5589765092E07D41D45DF9 + +Set 2, vector# 48: + message=48 zero bits + hash=B333735AFDAB30B4B597CCD137AC1AD2B30D4A047BAD0127 + +Set 2, vector# 49: + message=49 zero bits + hash=56CB89E287C0BCBC447C434C4E4C7D927B7C3A93A13A5122 + +Set 2, vector# 50: + message=50 zero bits + hash=D64C1E089406A1027991D7187E6BD88BE5E7B1564BF28640 + +Set 2, vector# 51: + message=51 zero bits + hash=624BFE886D307BB36C50CBDDF562B833DAB1B96288B568E8 + +Set 2, vector# 52: + message=52 zero bits + hash=51ED2437E8420E867AB602D439CD4E6839F4A69D57BD40CA + +Set 2, vector# 53: + message=53 zero bits + hash=7C345779353C5E33B55CADD6F543A8CDFFE8DD87C158D12F + +Set 2, vector# 54: + message=54 zero bits + hash=2DFF5DA66D3BFDBD16E576B8A5BED10AA7A59EF13FA06E56 + +Set 2, vector# 55: + message=55 zero bits + hash=9952AF5E64EEDE22CFCC24F22918FECF3B0C44DEDF27F574 + +Set 2, vector# 56: + message=56 zero bits + hash=1F27BB5926F35CF5D52A24817BF56CD17D79BB65ABE85785 + +Set 2, vector# 57: + message=57 zero bits + hash=7D7335252067E8E12F18BFCF5C1A77A39D5FBCF2FCF913F1 + +Set 2, vector# 58: + message=58 zero bits + hash=0396AE290E377B76F94F5EC9657F8E4F3420998D4849B26F + +Set 2, vector# 59: + message=59 zero bits + hash=6AD76B3ECA7E90F56B0134B72EA14D998E0FF816FC5E78EE + +Set 2, vector# 60: + message=60 zero bits + hash=AA5F69ED936D6BC41C0F0221980B66ED64117B6F0B2C474E + +Set 2, vector# 61: + message=61 zero bits + hash=5DBF4C39EDA1A12A83BE9D82B3B7008AD88FA5B1F069C32F + +Set 2, vector# 62: + message=62 zero bits + hash=2677DC2E7D3902ADF64225738948F7DD7BA7FA6450258A91 + +Set 2, vector# 63: + message=63 zero bits + hash=7DD158101DA48F6F9412B9E8E6628C91E33B836D5E8C2F17 + +Set 2, vector# 64: + message=64 zero bits + hash=5229DC51A494B913F8E04C4C729C93CB8B260CA4EE8EA9D7 + +Set 2, vector# 65: + message=65 zero bits + hash=2E31D53CD3D1ABF21EE0F99B481E2D52E88EF21D0CA826B0 + +Set 2, vector# 66: + message=66 zero bits + hash=73F693274A90C747D83F111D084321953CC1E283EE1C9652 + +Set 2, vector# 67: + message=67 zero bits + hash=47985F82E1B8EC4F3D6AD57CC6C808C201B5EB0C1E40ABBD + +Set 2, vector# 68: + message=68 zero bits + hash=CDDB515A9895C525DD4C4FBE1A93B89191AC030C5685C501 + +Set 2, vector# 69: + message=69 zero bits + hash=264C3C9C1EE792943225F5C57A274BAA448B950E6854F9FC + +Set 2, vector# 70: + message=70 zero bits + hash=DFDDCC7EE2DF96A970AA5BA756EA5D8A6E6B572306145B2C + +Set 2, vector# 71: + message=71 zero bits + hash=CC693DBA58877C05239C2A0BCBF77212A6F637C023BC6836 + +Set 2, vector# 72: + message=72 zero bits + hash=5DFE02959A64534E0E679937B712F7DDE2C7B982597D315D + +Set 2, vector# 73: + message=73 zero bits + hash=2EE34AE445DA43259FC63C0F4886A0D512AAAA9B340DE273 + +Set 2, vector# 74: + message=74 zero bits + hash=2F4E5FBD2060D6D18B9CD15FADB29F2DD5C9209A650678FD + +Set 2, vector# 75: + message=75 zero bits + hash=8A21DA997DD898FAE2470276DBDA548D1EC63C0E76193C60 + +Set 2, vector# 76: + message=76 zero bits + hash=821211AD301E77C6CCB2824BA6DA1EC482F16BC7D58F867C + +Set 2, vector# 77: + message=77 zero bits + hash=5508EE74EDA4BBC88247B0C833231274E3B739DAB0988A63 + +Set 2, vector# 78: + message=78 zero bits + hash=D733868DF262039B2B13C9FD71C197FF0A70CD866B8B04F1 + +Set 2, vector# 79: + message=79 zero bits + hash=3E767903CAD219A37AF1D393FFEC0CAB61FD90589F5239F3 + +Set 2, vector# 80: + message=80 zero bits + hash=654D00C774FBE74CFE4C0A6DEA5917823A6B20070CD0CCCB + +Set 2, vector# 81: + message=81 zero bits + hash=EC4581D397B5D69298088B30E558207768E66C7262D919EA + +Set 2, vector# 82: + message=82 zero bits + hash=BA1AA7DC59BB491E97F0206DD6571E28A4903A124DD3B72D + +Set 2, vector# 83: + message=83 zero bits + hash=E40EE08DA140B3CFF129EBBE819EEC73819244D98E033BCF + +Set 2, vector# 84: + message=84 zero bits + hash=A804CDBC07AAF509CCAA09D3E9A1F9F24CE682D507157F9A + +Set 2, vector# 85: + message=85 zero bits + hash=84AC1C96B4DD107A577D3EE45793C98BFEF090249F9D2E79 + +Set 2, vector# 86: + message=86 zero bits + hash=76267CA67FC1DBBF4A842D11484B4E7D5220ED5AA908D307 + +Set 2, vector# 87: + message=87 zero bits + hash=B10041175C43C47DF24BDB7A8680CE2B2707CF3EEB846E4C + +Set 2, vector# 88: + message=88 zero bits + hash=C82A6419844FC7028B52CAC8186D63B85121AAACBA622A87 + +Set 2, vector# 89: + message=89 zero bits + hash=DAD2E2635D2CE5B8721B37433EB43C308E26DA1324623011 + +Set 2, vector# 90: + message=90 zero bits + hash=73A42017104AAD84BBC78D0FCF9AD531F425AA71676D6429 + +Set 2, vector# 91: + message=91 zero bits + hash=4E9A41884476A21ADBB07E54F7C2886885B5B077B6201ACE + +Set 2, vector# 92: + message=92 zero bits + hash=89EBE56D435D7F5C16A730B03E3069241345D10C9E894DB0 + +Set 2, vector# 93: + message=93 zero bits + hash=5BA7A613DDFCA9DE97F6152B74C02138C2925A1550BA35CF + +Set 2, vector# 94: + message=94 zero bits + hash=21C1D3E7925BCDC70E59050E3B06BFB68E1F19112E82447B + +Set 2, vector# 95: + message=95 zero bits + hash=279A783027CD546358519CBDB2ED467CB8A09306F0DE9AE2 + +Set 2, vector# 96: + message=96 zero bits + hash=06F6D65EF081AFE892AC0946F275DBAB9D3B6D9C55E517C9 + +Set 2, vector# 97: + message=97 zero bits + hash=5AB93CF43A19AF13B183C725452F6B8F5D430EFF74100F0C + +Set 2, vector# 98: + message=98 zero bits + hash=ABA0354DFC6774D1D43610CABF2793A3041070802B11B37A + +Set 2, vector# 99: + message=99 zero bits + hash=FD71AC4A03E6C0DDC64596A373B749CE1276E5E46B8262C7 + +Set 2, vector#100: + message=100 zero bits + hash=E60C16B89368B6AFF0F0CEF144C206C69CE468A080B6D261 + +Set 2, vector#101: + message=101 zero bits + hash=8CCFBF9EB58AAA436F6484CF0A566E0D41DE85F693621F77 + +Set 2, vector#102: + message=102 zero bits + hash=5EBEE865394F1FD68208F0A921D73ABC4F4F0632B96EA129 + +Set 2, vector#103: + message=103 zero bits + hash=3244B2BB44E68FFC04A358146EEF8BB89644C9307CB6BEA3 + +Set 2, vector#104: + message=104 zero bits + hash=42C40537A876D69DF84FF36FBA3127901B112B9E96688012 + +Set 2, vector#105: + message=105 zero bits + hash=8DDCFAF9B36C347ABA5314670BFA62D64A3C8D097DC6B8F5 + +Set 2, vector#106: + message=106 zero bits + hash=9CA1C6ABD88E32CA3545410F610EF6A8588438E415FAF4E4 + +Set 2, vector#107: + message=107 zero bits + hash=7AF5B38C8C863D714BC187400D08DB045C74F2A7DE046955 + +Set 2, vector#108: + message=108 zero bits + hash=FAAA9B741A9D79B7BBBA11EDE1538D8CC480B9D788B67DD3 + +Set 2, vector#109: + message=109 zero bits + hash=0F275011F9D406E2930F5328997EC3C8CEF416C589CDCF78 + +Set 2, vector#110: + message=110 zero bits + hash=98F18618F5022F9FEC3A5250C1FF16DF590F8EF27E746465 + +Set 2, vector#111: + message=111 zero bits + hash=2514050BF63C408ABFE6B31AB656B84DD4ACC98840671074 + +Set 2, vector#112: + message=112 zero bits + hash=6FA00EB82505EBC4707F675B0A72A9F9795F647B550F155D + +Set 2, vector#113: + message=113 zero bits + hash=6D5627FF87C0D7F6AA45C601BAF0C59F280CD63A73D26C90 + +Set 2, vector#114: + message=114 zero bits + hash=A587B6BF983BEC315CDC974AD154BDB9483F4FEDAD76BBCB + +Set 2, vector#115: + message=115 zero bits + hash=2074971BA3054150FB36C46AC43183A2B128056F693C31E1 + +Set 2, vector#116: + message=116 zero bits + hash=030F292EF4743DEEC8B0B29F80279AAAD6E6722BA6817692 + +Set 2, vector#117: + message=117 zero bits + hash=072065FC399EA1F562DC1225D40E69671987D79A3D14CCEE + +Set 2, vector#118: + message=118 zero bits + hash=D7EBAC7EDAB4ECCEC85E072574EF3B7BD940F093C879E6D1 + +Set 2, vector#119: + message=119 zero bits + hash=E08377D7D8BBF2C6B31112B24EBFDFDCF0FAE8D872C87D55 + +Set 2, vector#120: + message=120 zero bits + hash=239549439CCE539F304CB7A95160A033529B228CA406EFF9 + +Set 2, vector#121: + message=121 zero bits + hash=FC10CAC34417F86387A1792540B1C5F8B8A232FA5FD1FD9B + +Set 2, vector#122: + message=122 zero bits + hash=0DE1DC3BDE99F25254EDC2CDF30C012E36B04766EE38B917 + +Set 2, vector#123: + message=123 zero bits + hash=7C585143A52234DCB28D103289F01DF2D277287F3AA3F114 + +Set 2, vector#124: + message=124 zero bits + hash=ACC4B1539649408FC256F268D5CBFA5C74B434C52A0121AD + +Set 2, vector#125: + message=125 zero bits + hash=BA664121D81F25551079BFA58C69393FFC8E9BBA48267076 + +Set 2, vector#126: + message=126 zero bits + hash=C962B717D1C15E8EF7908A148054C6CC23EE74D52231258A + +Set 2, vector#127: + message=127 zero bits + hash=6D95BB3A41801A653FDB1F56CA8FB5F352A3B781AEDFACFC + +Set 2, vector#128: + message=128 zero bits + hash=464B87921CCDAEDBC0D6941610D1EB19E536036096403F32 + +Set 2, vector#129: + message=129 zero bits + hash=D2230EF4D52AF33B975DA8999EC7ABFE7713D9D8B5DE54A7 + +Set 2, vector#130: + message=130 zero bits + hash=9E574D7D407BDEB00A3D784F8B7791E34A350914A20CDB7A + +Set 2, vector#131: + message=131 zero bits + hash=52C3130E642E64EAAEE9673DBFFFDD3029DF46359F885E4B + +Set 2, vector#132: + message=132 zero bits + hash=B8CB4B7425DA877097FB7DA13AC1192F4DA5A89633B1A5A4 + +Set 2, vector#133: + message=133 zero bits + hash=B985E6537CDCD919732C6C4658E74CD2D45496E37A0AB42E + +Set 2, vector#134: + message=134 zero bits + hash=BD767AC08E82D9F3752673BFF987F077C21770F04CDCDA00 + +Set 2, vector#135: + message=135 zero bits + hash=AA2BF0958BF94CA190A1EDFFD7D17D69AF4E90F347020C68 + +Set 2, vector#136: + message=136 zero bits + hash=F29CF9B53DA4F9955E7BB766EDBAD59EA914E5354DDF9ACF + +Set 2, vector#137: + message=137 zero bits + hash=6A1B4DB723F4B607F1CB773A2A72ABCDF7F41B1E64EF50CA + +Set 2, vector#138: + message=138 zero bits + hash=EDCD0CAFC9B6F741F46FD8668ADE02D957965E3B6AF69DD5 + +Set 2, vector#139: + message=139 zero bits + hash=0BAE83A29A6B9695E7B19DB730769DACFE487B5A54DB19D5 + +Set 2, vector#140: + message=140 zero bits + hash=978FE24933936BD50E395C290CD6A4079BCD1976299D7DFB + +Set 2, vector#141: + message=141 zero bits + hash=D382F4E925FE899ECCC3AE7BB59198813F6DEBE101D185C7 + +Set 2, vector#142: + message=142 zero bits + hash=3B6CFFAE0479EA6A67F6A6C5D803745CEEC7F1C7437462F6 + +Set 2, vector#143: + message=143 zero bits + hash=01AD724959CA32D97989567F492C87006C82A2E89DEB42B7 + +Set 2, vector#144: + message=144 zero bits + hash=E9B6BAA124BA93A4501DB9A92F212A14C538CF82C17E89B4 + +Set 2, vector#145: + message=145 zero bits + hash=52F79881C80B39B2D8A80E68848EE702BA842B44CAA80CCE + +Set 2, vector#146: + message=146 zero bits + hash=F596453768672C67D26FF95FFF16E0EC55F2EDC993ECA2DC + +Set 2, vector#147: + message=147 zero bits + hash=8043337BDEEB6C587568175D432EAF6ED97293908F0FC9E3 + +Set 2, vector#148: + message=148 zero bits + hash=31504BF60258347DB7E5E77C836913F1EFE61122B9BFAAAE + +Set 2, vector#149: + message=149 zero bits + hash=4A3C4471643DC81928287DCCFD5746977F171A4D225399AC + +Set 2, vector#150: + message=150 zero bits + hash=33E75B6E73EEFF0E8033298BC1441E4866E6228258860778 + +Set 2, vector#151: + message=151 zero bits + hash=59C50812D6B63907A5523BA2A8742FB1808EF33EE435E55B + +Set 2, vector#152: + message=152 zero bits + hash=03EB6D4703EFCF2E088515D3B902A1CF78711B7E7CE3AF74 + +Set 2, vector#153: + message=153 zero bits + hash=082009BCF5B82FBFD7925A6BE4B54D71A384A843A246E4C5 + +Set 2, vector#154: + message=154 zero bits + hash=7469C96361297C4440E12F8BC0CE15D131CED2A3E3D8B3C4 + +Set 2, vector#155: + message=155 zero bits + hash=BA94E4559E7E3C54F228112D2E2A49B4AE31DFCE0B03C4D1 + +Set 2, vector#156: + message=156 zero bits + hash=8C96E1DC34240E666012957D9B5EE0B423CEA57CE4BD52FD + +Set 2, vector#157: + message=157 zero bits + hash=79823387B86B517F0994CD12972DCACCED3EB94A0A3B9522 + +Set 2, vector#158: + message=158 zero bits + hash=47F179B6B6DC6EA6C418558801F6E5E6ACD1F1120478C40B + +Set 2, vector#159: + message=159 zero bits + hash=F3E38856AD4D70F839FC44F344DA7217D011F48EB94FA66B + +Set 2, vector#160: + message=160 zero bits + hash=53BFCB1EB5CA9B2E8A4225E6C00584023FF8AA0017AD3A0D + +Set 2, vector#161: + message=161 zero bits + hash=4B2D0F151C848FE28BFB27201CA242F1B863C59ECA5737F4 + +Set 2, vector#162: + message=162 zero bits + hash=6FD7B38DBC4DFBBA91A7ADEF5805F924A88464FC056FB2A0 + +Set 2, vector#163: + message=163 zero bits + hash=7F094A9B6831B9929D03AF95BCF5567DF49D0E1C15360A71 + +Set 2, vector#164: + message=164 zero bits + hash=3230A6EA60C990966F8345F5C68304613BE55FBE3605BA8E + +Set 2, vector#165: + message=165 zero bits + hash=F65F0E51FD4C0B70671A9FB1B29CCD877F8509FE4854114E + +Set 2, vector#166: + message=166 zero bits + hash=9E4B9EE43DC30458BE7E1D2FC51A12225FDBE60ECCD2EF19 + +Set 2, vector#167: + message=167 zero bits + hash=6831B3D904EF81FBFFF2FE7ADC30EF09BCC8A4C552D02E11 + +Set 2, vector#168: + message=168 zero bits + hash=67F6D2B74B13251432469B9CE6A7C91EAD6E72B9CB51CEF8 + +Set 2, vector#169: + message=169 zero bits + hash=EF232CB9815202CB72DFD9B8E37AE9560FDC0221C9F3BE14 + +Set 2, vector#170: + message=170 zero bits + hash=BD78688E71A3F0C70F1FE608EC27813C792B923CCEDC9685 + +Set 2, vector#171: + message=171 zero bits + hash=B585D2A299AEE3E10504A453A7391986A13BC385958902DE + +Set 2, vector#172: + message=172 zero bits + hash=FCF11F04FF7DDF91BE2EBB2D244EE15E5A1AAFBD8F05C95E + +Set 2, vector#173: + message=173 zero bits + hash=6F33F97A4CE83293ADBAEA9DC940936C20DD78F79059810F + +Set 2, vector#174: + message=174 zero bits + hash=9ECA5B82AF301BDB45DB2AFA3647DC0437E7E3DC4CCAD275 + +Set 2, vector#175: + message=175 zero bits + hash=25AB437B88A8435568D1ED483798878DF6ADEB0472EF93A9 + +Set 2, vector#176: + message=176 zero bits + hash=81A68B237DDC60C9C31B34B52A754A8A7B1F51D40781B988 + +Set 2, vector#177: + message=177 zero bits + hash=8B3F8554323D325E7CAE1E4D555660AD0B855ACCCF1E09CE + +Set 2, vector#178: + message=178 zero bits + hash=1585CB0936BE8C7CB01DBC72CAF67ABB845739EBA5D53C3D + +Set 2, vector#179: + message=179 zero bits + hash=7943970FCAFAA1394A3770BCAD50A0A5369530884D79FF47 + +Set 2, vector#180: + message=180 zero bits + hash=48EFC4A26AB1620074FDF0EB246EB37A4EF1254D03E506D5 + +Set 2, vector#181: + message=181 zero bits + hash=348A3EB8FED8212F7E94CE30AB164250CD9FBC7276951573 + +Set 2, vector#182: + message=182 zero bits + hash=7844EC5944F9CFE976D5B59C85F83FE0800B70AEDCB0D1D4 + +Set 2, vector#183: + message=183 zero bits + hash=D8BD30F4817F6AFCAA804E8953B5875373B35DB0ABC02F9C + +Set 2, vector#184: + message=184 zero bits + hash=E99E18449AEB4421CEC31D1521C23445BC2598EA5DA14A09 + +Set 2, vector#185: + message=185 zero bits + hash=46A53B5DC0DF07A7A242D2E7E880F66A405667335863F285 + +Set 2, vector#186: + message=186 zero bits + hash=4D0D93A77C41B4F8A2C0A65A0183432A34F0BAAF6A6C670F + +Set 2, vector#187: + message=187 zero bits + hash=39660BF03402BC44588263409E907F7DDF5A367926D117BD + +Set 2, vector#188: + message=188 zero bits + hash=6A6956D1549165712122EE87EDFFD263BA5F907694AE5771 + +Set 2, vector#189: + message=189 zero bits + hash=DD1CD1B51B221A7551E6C81B108A060E247DA99BF9216F15 + +Set 2, vector#190: + message=190 zero bits + hash=9451D3D12BD92FA84F8A72D6A078B2E5EEFAA422690D1326 + +Set 2, vector#191: + message=191 zero bits + hash=27197D44EA2B0E5F5FBBB775DE113B81B08E173963746813 + +Set 2, vector#192: + message=192 zero bits + hash=CDDDCACFEA7B70B485655BA3DC3F60DEE4F6B8F861069E33 + +Set 2, vector#193: + message=193 zero bits + hash=D507E20EF2AFFE67D2D8BEC5FEDD3C007729049CE31C53A4 + +Set 2, vector#194: + message=194 zero bits + hash=D0EBA5D323155E31AFCCBDB6BB52D18718197D2508B80176 + +Set 2, vector#195: + message=195 zero bits + hash=29D678AD5B64735C11DBCD29D5D63F8F39040F22DDDC9F3E + +Set 2, vector#196: + message=196 zero bits + hash=E1C3030EB0A37646147257AFDEA5F0CD4212E9F708EF42D6 + +Set 2, vector#197: + message=197 zero bits + hash=4C545BB03C662D4E25A2D0768F808952632AF357EB94E557 + +Set 2, vector#198: + message=198 zero bits + hash=875B923A3C36B226C5F3FF101DE1B4B9823C53056D0E9279 + +Set 2, vector#199: + message=199 zero bits + hash=CD9E6FE8DF4D801FBEF41A5240D206D0EAD97131BE4E52C6 + +Set 2, vector#200: + message=200 zero bits + hash=424CDDE2E5478A29A71352AAE538EAFE9F1B6F07AE05137B + +Set 2, vector#201: + message=201 zero bits + hash=995E56D393BB35480B66AE84256EE86D3261164949A1E8E1 + +Set 2, vector#202: + message=202 zero bits + hash=11659EE7372F8CFC9537DD28E0D7DAEE1F180A54A341620A + +Set 2, vector#203: + message=203 zero bits + hash=9E3DE768550294AD75853C7D5A5F433105E79DE5B8A5EE20 + +Set 2, vector#204: + message=204 zero bits + hash=09CB03BB7FEC2F4C63DED38B01A950D14BB5D858099CBAF7 + +Set 2, vector#205: + message=205 zero bits + hash=1702EB3E6032178A5B60825E8DBE4754105651C49B18CA2C + +Set 2, vector#206: + message=206 zero bits + hash=49FBE65A50747A1D8088B1DC0A79AE197A056394A5F85860 + +Set 2, vector#207: + message=207 zero bits + hash=D0F5B3BC5D071E03D05F7C09D4953AA289FE10736951CD88 + +Set 2, vector#208: + message=208 zero bits + hash=996B4DD292782A19D742B534916870023F32E72F1C197625 + +Set 2, vector#209: + message=209 zero bits + hash=463853DEFC2F5AC1C60FCE25747F2A99CB8CFAC8DEC77875 + +Set 2, vector#210: + message=210 zero bits + hash=9E44B238B5C34B34D69D8018E45028856B53231FD9F25DF0 + +Set 2, vector#211: + message=211 zero bits + hash=995B707087373EA186CF9A2876897D3B1F67069A296FA7C7 + +Set 2, vector#212: + message=212 zero bits + hash=5BB269F595183A5ED732ADF97D6554F06578AFA866E7DAF5 + +Set 2, vector#213: + message=213 zero bits + hash=B3A185B73F912A04DA88518D4601D27346CFA5E0872DEC26 + +Set 2, vector#214: + message=214 zero bits + hash=9547130F960DD5A682FCE6E01D8C8516AAFB2A0CE5DF9E6B + +Set 2, vector#215: + message=215 zero bits + hash=88B1D853AE7ADB39C8959CA9B6EBC13F8E336C4DC4136E7C + +Set 2, vector#216: + message=216 zero bits + hash=2C4B719E5E0BFBBA616FB8AB35470D84B676C7D3A6395262 + +Set 2, vector#217: + message=217 zero bits + hash=86770BC6BC120A52E3AFA6E45D4FE9A3F72622DD0E2202A8 + +Set 2, vector#218: + message=218 zero bits + hash=751FA526AE68FF8EC6E8BAE548B5916115A6F6E7DE68AD92 + +Set 2, vector#219: + message=219 zero bits + hash=64DF6C1874F7924033E8ED56BDE011F8533DF2F8F809DCB8 + +Set 2, vector#220: + message=220 zero bits + hash=CE186E5AA07D65B2DCA8889A03DB729F141A709793415ED7 + +Set 2, vector#221: + message=221 zero bits + hash=E0673B2995E3706D779A79FF8876A3FBDAB27F615ACF75D9 + +Set 2, vector#222: + message=222 zero bits + hash=13DCC16CB6094283D1FE7B2E66AC75BC5513716A08FB2999 + +Set 2, vector#223: + message=223 zero bits + hash=AF9874E0C405C0FBDF88E99E8F3B06730A77BC823946096F + +Set 2, vector#224: + message=224 zero bits + hash=F178E06FC3319BA18F2EAC3DCC5240D06BAC062BCD5CA1CE + +Set 2, vector#225: + message=225 zero bits + hash=ECA63E62EAF2BFA0442D3402E38DA2079C13704C3570109D + +Set 2, vector#226: + message=226 zero bits + hash=AC7A917CF8244BE8AAC81C2C7690AA37D8047BF4E3EF472B + +Set 2, vector#227: + message=227 zero bits + hash=B46E474162D3EFFBAEDF854D54724F68BAE618F13DF1EA20 + +Set 2, vector#228: + message=228 zero bits + hash=F118D23A3759BB3924CD28E4F56312E59270AB2971432E04 + +Set 2, vector#229: + message=229 zero bits + hash=A27CE999BD56A6E64BE9D02FEC7000DEB9B6D54D2BEC6E1F + +Set 2, vector#230: + message=230 zero bits + hash=E91A899EDF44005D73E36A31C082247225E4EBAA2D400C55 + +Set 2, vector#231: + message=231 zero bits + hash=DE716C5BA7E71690DF91852593D16BE622BC1EF5E514ACFE + +Set 2, vector#232: + message=232 zero bits + hash=E899374C34AED37FBC9E0E4A0D37A13045639D5CAF24095A + +Set 2, vector#233: + message=233 zero bits + hash=EB926C1EFA2CD7D222A9DA75601FDFB7CDD15A6E3BFACD7C + +Set 2, vector#234: + message=234 zero bits + hash=29C4C6EF8738FC8E580232A5C320F08150E0273E502A386C + +Set 2, vector#235: + message=235 zero bits + hash=D9A059917B57A175EA3FB1AFF9EF197598A8C3DE96CFF80F + +Set 2, vector#236: + message=236 zero bits + hash=128C51808702CF4C53FE5ADE29C880196960C210884998E9 + +Set 2, vector#237: + message=237 zero bits + hash=89A8673B8C41D9E00CDED45FFCEE30C63D96C10A5707C47A + +Set 2, vector#238: + message=238 zero bits + hash=068B643C582179DE8FB0C0B0BB828D78D6089CA3673EADE5 + +Set 2, vector#239: + message=239 zero bits + hash=4B4E83DDC7236551415145F9818462BA25ACDDAFC9B94717 + +Set 2, vector#240: + message=240 zero bits + hash=3D8E74F26682750FEEDE30A305C9CA162C6BDD9B790BCC5D + +Set 2, vector#241: + message=241 zero bits + hash=CF57B0BAFCBD670D48D52D22E94CFC9DA1A7EA1F80923A06 + +Set 2, vector#242: + message=242 zero bits + hash=F94903F2F2AB91C9491EA66C7A98401F869ACC1D8010C710 + +Set 2, vector#243: + message=243 zero bits + hash=DF58EE17B266D0F132AF119179BFAF48DF41331DDCD8D464 + +Set 2, vector#244: + message=244 zero bits + hash=D74207B746B3DAFCFC8E38E0325998FB2E1219720DCC643E + +Set 2, vector#245: + message=245 zero bits + hash=CF843577B294A8177F18BFD08B2DD8158E1CFCA349F99063 + +Set 2, vector#246: + message=246 zero bits + hash=6E932AEA840E75D2C4E3549DDBB4F7DE030C61E29A3DF067 + +Set 2, vector#247: + message=247 zero bits + hash=5D53EE60FB695539CCE16914AD2A8E477EB94E0803728FD5 + +Set 2, vector#248: + message=248 zero bits + hash=3EFCD915BB46020B8999C9AD56356FB91F93C4907C4012D5 + +Set 2, vector#249: + message=249 zero bits + hash=98A1A4E1C0D37DAAC9119697E1A5AE59BC8829340A496BE2 + +Set 2, vector#250: + message=250 zero bits + hash=293DE385ABAAAE0702A6A6B1D6FAAF852529C0B1CEEA87B8 + +Set 2, vector#251: + message=251 zero bits + hash=C41A3D530973C7A12EFF41D6D7E0EB2D305E21D74C68FCB3 + +Set 2, vector#252: + message=252 zero bits + hash=182CC87B2ECB0B8262792B868EB77D7AD86ACA5A605E930B + +Set 2, vector#253: + message=253 zero bits + hash=D519F8F5EA54C9CCE2756C1941275E0F99996F76D3BD5682 + +Set 2, vector#254: + message=254 zero bits + hash=1B7B457C663E971B4CBA01D03FD5A4B114DE021FF7C13ADF + +Set 2, vector#255: + message=255 zero bits + hash=A29BCE5D377367636E0F137E809D869BA472B1F798488344 + +Set 2, vector#256: + message=256 zero bits + hash=739414BD4CD6AB967CD46A1D943412757D858B24D1C4ECF7 + +Set 2, vector#257: + message=257 zero bits + hash=D265FAEA2CFACD294FDD8E9C1687C2D0DD8095DA77045362 + +Set 2, vector#258: + message=258 zero bits + hash=72E2C3BF21DDD1D9E9FFED653CBF27F21C1304B1A979280C + +Set 2, vector#259: + message=259 zero bits + hash=1ADEB44B5DD6144F37A430AA5CDEE6E87A54608BDDF86FED + +Set 2, vector#260: + message=260 zero bits + hash=693DF9F1D66ECF72041F44897806DB1FEDE9485C38D73680 + +Set 2, vector#261: + message=261 zero bits + hash=D90251247CF23FC5F210D6E8CDB9881DC3B26134B2562D00 + +Set 2, vector#262: + message=262 zero bits + hash=F887A6A5C7D6ED702E5EA0774BBD301600EB0A41397E44B8 + +Set 2, vector#263: + message=263 zero bits + hash=1B9EEDFEBE055430699B64D3773C0ED1785372001D6A94A2 + +Set 2, vector#264: + message=264 zero bits + hash=3615FE2BB3B94A00245A1B3DF68B9D43BBAD82B16BFCD6A5 + +Set 2, vector#265: + message=265 zero bits + hash=8AC9AFB779EFDBB5C2CA2C9080FFDA39763F74A973697889 + +Set 2, vector#266: + message=266 zero bits + hash=D871F30BAAE8582CA5AFFE92E79E5F463CD5906AD086441F + +Set 2, vector#267: + message=267 zero bits + hash=1FDCAB3BAC2B7181A34F3031DB46003981192370E6BBB953 + +Set 2, vector#268: + message=268 zero bits + hash=FE49517B506090C44543320397A11D8B77CDA5C6F13CB10F + +Set 2, vector#269: + message=269 zero bits + hash=FF4D54E6589BF784967D3F02BAFE01D4B2DEB7C01A086015 + +Set 2, vector#270: + message=270 zero bits + hash=84A140DE357F866F5FD4527C66CF1EB1825101F7ADCB0948 + +Set 2, vector#271: + message=271 zero bits + hash=AB528CACAD90CBA6CF89EB3F63573A5D4332F882C7CE71F9 + +Set 2, vector#272: + message=272 zero bits + hash=9E9AD6783D3775885E65D05EDA4262E179836ACBB9867CE2 + +Set 2, vector#273: + message=273 zero bits + hash=D5ACE92C4F333668EC8FC0B9B940844BB2ECA10BE0AE9156 + +Set 2, vector#274: + message=274 zero bits + hash=E0FF3D4712C5713446F6D5D997573631A06AFF779D791E27 + +Set 2, vector#275: + message=275 zero bits + hash=57A658AFE0CA0BF103ED10CF6E49E3A94FA3C89E51DA140B + +Set 2, vector#276: + message=276 zero bits + hash=84D4A2986640BEBC1BFCF3C4AEAE8EDC91A94C0E69AAE51E + +Set 2, vector#277: + message=277 zero bits + hash=F3926291AEB75587B0B8D575F5F1A27C89D9AB24A4B6221B + +Set 2, vector#278: + message=278 zero bits + hash=4847B57AEE24F48811ABD2CB9978AD5DF8501A3DAE286AB4 + +Set 2, vector#279: + message=279 zero bits + hash=5CE3715F4689C9ABD5F180A11E22A18201F044FDEC6644F9 + +Set 2, vector#280: + message=280 zero bits + hash=5D91C8314556534FF3DEE0515334F09E16935538E347C029 + +Set 2, vector#281: + message=281 zero bits + hash=B13A7BBC81055580B02B4CA3DFEBACD66A178098BC94E25F + +Set 2, vector#282: + message=282 zero bits + hash=D902017A6A6EE71E4A0F71BD78F7AFAC7CBBE2E7719A716E + +Set 2, vector#283: + message=283 zero bits + hash=26BBD441CAB9A50A9CEE2398AFFCFB745AC5946B010ECDA4 + +Set 2, vector#284: + message=284 zero bits + hash=6A6697B6DA1A669F9477D1418604DFFD4EF4F00025369064 + +Set 2, vector#285: + message=285 zero bits + hash=4753A53A1E8FD3A836888089878C79EF52AC4839DA881E9C + +Set 2, vector#286: + message=286 zero bits + hash=7EE9E4268BA0E5003F27BC070C52D21E995957A52D435210 + +Set 2, vector#287: + message=287 zero bits + hash=06B4D0E4C5892094EFA987A2037EC844D4EA61AFFA2C4E60 + +Set 2, vector#288: + message=288 zero bits + hash=E48325D26CBEA5C14AF5D2BC043242DE2A5DC17EF5798BA0 + +Set 2, vector#289: + message=289 zero bits + hash=C0AB19DAFADC7090E5A43A66D3ADEBF9201204C0856E056D + +Set 2, vector#290: + message=290 zero bits + hash=2A39E534C11E9232B5B46CC2F75AC715446AC532BA42422F + +Set 2, vector#291: + message=291 zero bits + hash=307067862B277E69ACB6EB49F7CF182E74F41505CAAFFBAD + +Set 2, vector#292: + message=292 zero bits + hash=7AF0C85AD9358907F2A191B0B5CF4044003FE50D69921EA8 + +Set 2, vector#293: + message=293 zero bits + hash=17EAEF6C0CFF6930B34DC020F331FB657BDBBED88FA6705C + +Set 2, vector#294: + message=294 zero bits + hash=6BED7F7314514B384C139811BFAF08121DF6DBC9550EA21D + +Set 2, vector#295: + message=295 zero bits + hash=73163CFF1F811E8C56D8E5F076412321CFC1A55DADEF1855 + +Set 2, vector#296: + message=296 zero bits + hash=0DE25B928CF3E4FE85F46C18334D9C9DAE995E4889068C4E + +Set 2, vector#297: + message=297 zero bits + hash=E3A4425BDD588E8415293521CCB6E135E27960252E160D19 + +Set 2, vector#298: + message=298 zero bits + hash=8261DC34670705EB0250054DCF6062D9B91E083F09695CC0 + +Set 2, vector#299: + message=299 zero bits + hash=00AD05F76C41974C04A9C3D5CA5E4D53E74F24BA0F181984 + +Set 2, vector#300: + message=300 zero bits + hash=07C4DA723EC91666017C5B7235140FA07976876D05EE534B + +Set 2, vector#301: + message=301 zero bits + hash=9341A937CBE62F7B0EDF4493209741E1491249A584DF4A29 + +Set 2, vector#302: + message=302 zero bits + hash=2612C32F1C29AB6B58159EA81C4E0779C13CDFB5307BA77D + +Set 2, vector#303: + message=303 zero bits + hash=4056019CAFF2472981A22A256FDD1A0C6C70028C454665C2 + +Set 2, vector#304: + message=304 zero bits + hash=1BD4360038C1282E66538B156E9F604AA0262D4608184A5C + +Set 2, vector#305: + message=305 zero bits + hash=B96EA7517576851B2BC13DCB5C6F7391AD7122643F0CB571 + +Set 2, vector#306: + message=306 zero bits + hash=EEC34BB528EC15D14412EDE038318113DB4AD6A24600684D + +Set 2, vector#307: + message=307 zero bits + hash=D38CCA82EEA448448DAE01C300762F26367BD25BDD0E7EFE + +Set 2, vector#308: + message=308 zero bits + hash=E3702EB44AFE7EBC18DD0845256F34121AC49F6B7BBBEC85 + +Set 2, vector#309: + message=309 zero bits + hash=D5F6DE3CBF98622D792F26404E3C9C2CC1FA4AD5F028CF11 + +Set 2, vector#310: + message=310 zero bits + hash=9BE9550E3373C58077559B598FDD20B381DAFC4A9A2D4537 + +Set 2, vector#311: + message=311 zero bits + hash=C9C471424AA6BED291732A74A4DF1FB64B71837DFE05E43E + +Set 2, vector#312: + message=312 zero bits + hash=FCC72686AD012FF48D1471CD0EAD606EC21A5E496DB66103 + +Set 2, vector#313: + message=313 zero bits + hash=158F6F66FE465F61A134DAFE329E70D49F343A658DE77532 + +Set 2, vector#314: + message=314 zero bits + hash=7ABBDE244ADBEBEAA31399955155E30F69A6C7E5AE35EF40 + +Set 2, vector#315: + message=315 zero bits + hash=EF3A4B8AA5800F434A4D3085D9C2232C50A7F77A9FF04049 + +Set 2, vector#316: + message=316 zero bits + hash=59E7766097F2D40016A02EE4357C3011AC21D4B50F71AFE3 + +Set 2, vector#317: + message=317 zero bits + hash=66B6407BE96D8A1008503AF829CB8B340CD1AFADCCD2C154 + +Set 2, vector#318: + message=318 zero bits + hash=5512C01D4983348720AD4ACBBB9FE07AA5C6CD9C134C784F + +Set 2, vector#319: + message=319 zero bits + hash=ED36467A25C9B6055F6CA9C6500457743D02289FC9F3C768 + +Set 2, vector#320: + message=320 zero bits + hash=F11D39950658DBDF786703E3EDAAA3A654B4428AD419DF11 + +Set 2, vector#321: + message=321 zero bits + hash=FC44AF74FCFB97CBFFFA8F49A305FED6F0CF091C5555EDBE + +Set 2, vector#322: + message=322 zero bits + hash=52D8C7EB89A0ED303290A5BEC7D9FE939F1DE5011A73A24B + +Set 2, vector#323: + message=323 zero bits + hash=1BC88EE45F3F639D35C7B2A7C1945F0A8E11A0D631BACF15 + +Set 2, vector#324: + message=324 zero bits + hash=2080C3D01E26907A6E9536F3CBA4B83CF3CAB77959D33E50 + +Set 2, vector#325: + message=325 zero bits + hash=41572C7FF10D1C77C5A9754E31E8D4DE1125E2189F12E662 + +Set 2, vector#326: + message=326 zero bits + hash=7A2F4FA19134A80C04448E7010DE975F0AAB61A9186265DF + +Set 2, vector#327: + message=327 zero bits + hash=1C73ED616AFC10A06A484BDA0F3E31C043F14B0941C63092 + +Set 2, vector#328: + message=328 zero bits + hash=2AFACE18DA68984D907D1C0F647E9244D6976F4F471064B9 + +Set 2, vector#329: + message=329 zero bits + hash=D6440F08472C445077794D59D9F7FF690C476D58BC099C7D + +Set 2, vector#330: + message=330 zero bits + hash=A8D1985EDE98057EE1490F3FEEBE0AE5FF9072A5F4CB1D25 + +Set 2, vector#331: + message=331 zero bits + hash=683FD77D4E9A591E4051EEEF767161AE1F38422583CB7E12 + +Set 2, vector#332: + message=332 zero bits + hash=8F8FDE1BC53364E2B6C89ED3A4D80B8C69BCDD73D025616D + +Set 2, vector#333: + message=333 zero bits + hash=40917AAA260BAB49CEFCBAFC473A896FAC9D5EFAE171A5C6 + +Set 2, vector#334: + message=334 zero bits + hash=77DB0429DBE25A41DA836808895BD948826C7A2C8D2B6E32 + +Set 2, vector#335: + message=335 zero bits + hash=9C5FCB73F0A437D9BC652EDD5814B1FC55D6E8D0FDF80465 + +Set 2, vector#336: + message=336 zero bits + hash=E2056969720C08B5C9C8F903416668A7F5B2D6F95046C5FF + +Set 2, vector#337: + message=337 zero bits + hash=1F9DAD81EDF9595A3872A6980AD4E2BCAD219E4B1893D107 + +Set 2, vector#338: + message=338 zero bits + hash=F232A5C5062C6B55D26FADF4DB7510E37537EE5039D3E458 + +Set 2, vector#339: + message=339 zero bits + hash=E1B0B6D9105482A76DB5852F76D02E432D6F1C02EA1FB43E + +Set 2, vector#340: + message=340 zero bits + hash=A0E27771E51A3976E7262D092CCB0FC65184CFE30C85DD9E + +Set 2, vector#341: + message=341 zero bits + hash=DD1F563470929BFF82A9FB979748DA0FE54698E7566D87B0 + +Set 2, vector#342: + message=342 zero bits + hash=3C4D5C146E28703E01A7202202619038E44A7637A28B7FC9 + +Set 2, vector#343: + message=343 zero bits + hash=5A2C91F9FF8B5242FFDBF35689FABAD91228ED65C5EABAAA + +Set 2, vector#344: + message=344 zero bits + hash=D95BC879A68D549A5296BD34344C5ACC4D826E54ECEC346C + +Set 2, vector#345: + message=345 zero bits + hash=9A175185D3913FF913DCFBC81070DC467D8E1C2E4799FFC7 + +Set 2, vector#346: + message=346 zero bits + hash=557AAA123B10DFECDE0440CA11FC882C48642BB5844E87E9 + +Set 2, vector#347: + message=347 zero bits + hash=ED78BF444031317EB7BF41F3008604E52EA287E88CF401D0 + +Set 2, vector#348: + message=348 zero bits + hash=69BF72F8422455645C841985FCC00B545D4CC3C87FD597CD + +Set 2, vector#349: + message=349 zero bits + hash=2FABCB8173C04E739971113F4173AECDA305CB3E673662F0 + +Set 2, vector#350: + message=350 zero bits + hash=C2C747303F258C981D214FCE462D1F1E24295C724A2EFA57 + +Set 2, vector#351: + message=351 zero bits + hash=A8130996CEB9C1C021E5C8CEDB55A44DDA56EF2EF4001EBB + +Set 2, vector#352: + message=352 zero bits + hash=D33A7246729743643BF4B438FBB9BC2374F9E346A0868DC6 + +Set 2, vector#353: + message=353 zero bits + hash=E4EC4AD2CCA6183545501ECC33C78F895B8DCFBE8E5EBBF0 + +Set 2, vector#354: + message=354 zero bits + hash=D72FBA37CF967845B9D7D5441C1E76DA762E559D8CD0790D + +Set 2, vector#355: + message=355 zero bits + hash=D7015D9F168D9E90939EF15994A3A4CA60A6A36B2D5F6E3B + +Set 2, vector#356: + message=356 zero bits + hash=2F6A5DDFAABB8D6C4B29276FAE46B14FBF444D29C3F03E81 + +Set 2, vector#357: + message=357 zero bits + hash=1E7D14CDEBDB776789F06A394ED42D272096C18405F72C38 + +Set 2, vector#358: + message=358 zero bits + hash=F91073D2422729ADE2D84ADC16DE6E068F01BDE41314FB19 + +Set 2, vector#359: + message=359 zero bits + hash=04FAF52202275080A915E3ECE47B7A5C5B85783C3B266D3B + +Set 2, vector#360: + message=360 zero bits + hash=1201A8247225F31B928390B35787C046653249D0441F0AAD + +Set 2, vector#361: + message=361 zero bits + hash=EA00FF4C51766DAF8F05832C7704E4E5F761593D70DCB3BC + +Set 2, vector#362: + message=362 zero bits + hash=8B5AD5C3FC03A5C57550D00514312B28B21B60247DA6E8E0 + +Set 2, vector#363: + message=363 zero bits + hash=3B07F8BC2E48AE0DE40743B35F90D24EAACDD87F9E8A103A + +Set 2, vector#364: + message=364 zero bits + hash=2C3AF9BBF42BA704AC1CFF50712300C0208B996BBA2CD6FB + +Set 2, vector#365: + message=365 zero bits + hash=8F0492DC54D3013634F3C1D15020B0DAF91290BD5708ACEF + +Set 2, vector#366: + message=366 zero bits + hash=DECC27A83F6DBD7A11E97362CBCE393771CF554A6B29313F + +Set 2, vector#367: + message=367 zero bits + hash=F54330CF39C14C1AAF67C754CB46C7455A119F3024482B76 + +Set 2, vector#368: + message=368 zero bits + hash=1E63B6124EF57A92B36C8FF837C38CC9072048ED98EE853F + +Set 2, vector#369: + message=369 zero bits + hash=9FF29043D626941F044FCB85EF3106EC79295549AB9857F4 + +Set 2, vector#370: + message=370 zero bits + hash=7A18CC98E15DB828734E19F2A92CA67FA7B0A76B41B37DB1 + +Set 2, vector#371: + message=371 zero bits + hash=4646BEB63903896484AF974A7909F7E5E37EE713794A5682 + +Set 2, vector#372: + message=372 zero bits + hash=BF501E591AB9C2224F40FDB7E3CB2F772641A30981BABFD6 + +Set 2, vector#373: + message=373 zero bits + hash=E02F96821F8A80C974C3DC6FBB2261A5089BB8248563D9F0 + +Set 2, vector#374: + message=374 zero bits + hash=9233D832B93149A9F0C7B4598FA5A5788C2B0A677BD910EA + +Set 2, vector#375: + message=375 zero bits + hash=FC16E5E7AE7F18BC973A6A380D783745921E269F822764AE + +Set 2, vector#376: + message=376 zero bits + hash=F2E4B6637FDFF18F785894EECEA514E7B96B2409E62DF3FB + +Set 2, vector#377: + message=377 zero bits + hash=96B6213F10B67BC775FBA5A1A7AE6044FF9D0801D24662DC + +Set 2, vector#378: + message=378 zero bits + hash=1F6AC762BE8B8B4E4FA998022420BBA027174DE7D260D570 + +Set 2, vector#379: + message=379 zero bits + hash=942FEC93915205169E00A0B3566150593F64F3130B937B5F + +Set 2, vector#380: + message=380 zero bits + hash=081E9CFD455A715FE487B9C1758ABD4ACEDBA7395FC479EE + +Set 2, vector#381: + message=381 zero bits + hash=11E864E0138433B360ECFCE823FC33A3BC6481C5DE5C95CD + +Set 2, vector#382: + message=382 zero bits + hash=965AAFBD0832E5C1736518A9CCC8B3FCC083B18472C2F93A + +Set 2, vector#383: + message=383 zero bits + hash=D88A92D373B875143778B905DC2C55773EF4F851BD38DAF9 + +Set 2, vector#384: + message=384 zero bits + hash=10DD94B66BA6AE0498C9C7754844662E5D8B62E27D2C4D26 + +Set 2, vector#385: + message=385 zero bits + hash=36C383749AE2D62CD8A88C363F3CE84B9480D466CB848908 + +Set 2, vector#386: + message=386 zero bits + hash=367998CC80C1A97689FADA48E3F468A0C0D2BEBA3DC6173A + +Set 2, vector#387: + message=387 zero bits + hash=B6D8846050D4D6BD95D5D2F101E0E86BA975103653BB7AD2 + +Set 2, vector#388: + message=388 zero bits + hash=C87528E06CC91F6B68BCDDE94917709AF10F8EA6A107AF36 + +Set 2, vector#389: + message=389 zero bits + hash=3B4638A52AB4ADDDD549745CC19EEEB6DE416F66BEED28B0 + +Set 2, vector#390: + message=390 zero bits + hash=CA16D435CC34DFBFB75275CF585E81DE5DFD985555615D98 + +Set 2, vector#391: + message=391 zero bits + hash=AD254F17CDF0DF0EEFD4C5FB027A8E8EC41E43453AF27777 + +Set 2, vector#392: + message=392 zero bits + hash=8BD37E3CF05E59537389672DF921392A45CB57ACFE9247A1 + +Set 2, vector#393: + message=393 zero bits + hash=6BC753092DF48B959F6BE285C6AD319D331FADCA850C20D0 + +Set 2, vector#394: + message=394 zero bits + hash=8E6F31F4F49CF2926491B83D4600EFF9934A7375DB395F2D + +Set 2, vector#395: + message=395 zero bits + hash=44EEB169A54F26D4B861FE39FB52359551512B767CB07592 + +Set 2, vector#396: + message=396 zero bits + hash=274A4042B6F4B3E483A77B31185D4665C0B0B8EC2BD58C91 + +Set 2, vector#397: + message=397 zero bits + hash=EAE04ECE750F890ECDA1F4704F0435AEDF9A8F2CE0D1AEC8 + +Set 2, vector#398: + message=398 zero bits + hash=900641C1AFAEB902F0934EFB2E8AE820D9E20442D84B5BA9 + +Set 2, vector#399: + message=399 zero bits + hash=BD939BD0FEEFB953D0019194531012433E2634F387119C8A + +Set 2, vector#400: + message=400 zero bits + hash=41621DF28B038C0032508592F986C7C4832927CD1134B2B4 + +Set 2, vector#401: + message=401 zero bits + hash=33F19F0EAF0EC42E040F5DF46162F083631C8FE00EE46162 + +Set 2, vector#402: + message=402 zero bits + hash=E11E916E145716BC9F80B6273134D8C5143A61B378EC91CA + +Set 2, vector#403: + message=403 zero bits + hash=57CBD28EB525504C5A272E3327BCD2F4190229B8B9F7F279 + +Set 2, vector#404: + message=404 zero bits + hash=3B3434C29240AFD5CA355EDE8B74A19A1A0BC0AC88FA65B2 + +Set 2, vector#405: + message=405 zero bits + hash=2317B6DCFFEADF813E9F1192CB930247C1E241117C844ABF + +Set 2, vector#406: + message=406 zero bits + hash=6D99C0AF36EF7F66558E95832BA723E9FB2C1EB3FE8686E7 + +Set 2, vector#407: + message=407 zero bits + hash=A12CE9B7A5C8657192C6BC5855288AED86EEB87637CA5CD8 + +Set 2, vector#408: + message=408 zero bits + hash=978365EDBC762C10187F212BF9115D79FCBD489EC135AC9A + +Set 2, vector#409: + message=409 zero bits + hash=690940EBEA1D40FE2BB6822973FBE0119C242F1635931DC5 + +Set 2, vector#410: + message=410 zero bits + hash=7982BE271D2691F6CC6AA906714750C2DAEFCFA8C01C8BE3 + +Set 2, vector#411: + message=411 zero bits + hash=2B00C2BA54B99BE354884C0A3050A543DA810615F02B42FD + +Set 2, vector#412: + message=412 zero bits + hash=883DDEC3E4C6878F27D866B8A8685BA33EA08DB12CACA4AD + +Set 2, vector#413: + message=413 zero bits + hash=D1996CB317DA1386D3FA3DE1DF8B95164700F351B51946E8 + +Set 2, vector#414: + message=414 zero bits + hash=218C1ACC812BD8EA24C2C50E7F4131412795B8144C3A5B7D + +Set 2, vector#415: + message=415 zero bits + hash=1F0E7D9174E1280D63957806A344B89A5BBEC53F206F490D + +Set 2, vector#416: + message=416 zero bits + hash=8C4A9C341016B2D74E1DC75478A20A57EC934C38E6D60DF3 + +Set 2, vector#417: + message=417 zero bits + hash=0B9772283AD857C9B9F1FDB81A826FE4652F6213A9046350 + +Set 2, vector#418: + message=418 zero bits + hash=4AD781E0F0E5BE2EC6ECA33F8D183CABE7FCE59B42499887 + +Set 2, vector#419: + message=419 zero bits + hash=C56ECCA0306F0971F98DAA967AE7AAB046D84D3A9770DEB9 + +Set 2, vector#420: + message=420 zero bits + hash=E4B070DC98F4BF10DF829C1ECE2BDD30A45D53B6F3F6BA4D + +Set 2, vector#421: + message=421 zero bits + hash=239CE0F2E57B6D19769C669D245314B1A7208202406D1439 + +Set 2, vector#422: + message=422 zero bits + hash=4D09271AEA1915A0B1C2DF6D883B238D71CB70A2DAD1D04D + +Set 2, vector#423: + message=423 zero bits + hash=9842FE21812F95C1D8961C8ACDC69D34FC8DEBC33EEBD953 + +Set 2, vector#424: + message=424 zero bits + hash=FD5A1DDED7D38B987B582FD91E95FF8ED84DDF5D486A00EB + +Set 2, vector#425: + message=425 zero bits + hash=6D712A0F71A8DD9BBE7962CC771F63A338CF5B7463B677C4 + +Set 2, vector#426: + message=426 zero bits + hash=CCE2900327EA3A34166D9FBAA768FCE9EAC3F9A97EDDAD82 + +Set 2, vector#427: + message=427 zero bits + hash=0117053F4A107000411FC39134462CF155F83AC7F7D08F97 + +Set 2, vector#428: + message=428 zero bits + hash=A93AE5F7041656EF301AF20261DA6140DF3B148CBC4FD2A5 + +Set 2, vector#429: + message=429 zero bits + hash=74EC899ED93078EC109561314A3969F0A109D4672A1BC327 + +Set 2, vector#430: + message=430 zero bits + hash=117AC491A916479BC439A23B64A42E45219233DD0AEC4EC6 + +Set 2, vector#431: + message=431 zero bits + hash=E98C7B0B3ECBC0BED36E00FECF3595FB24A66CBA09167BDA + +Set 2, vector#432: + message=432 zero bits + hash=F5845CBBA386319361D4042658606947FB96D72934378AA3 + +Set 2, vector#433: + message=433 zero bits + hash=1AD9B83226DE9FF28ED8A8F726080EDE26DB39CC9A33D56E + +Set 2, vector#434: + message=434 zero bits + hash=834A29F3BF5E4257861F0535DFCCF584A790EDD4C0906703 + +Set 2, vector#435: + message=435 zero bits + hash=D491255D7BF23C021FE4470DC4B97B422992EC162E39970D + +Set 2, vector#436: + message=436 zero bits + hash=678C80A5A5297C8CC1526C6BF319AAB9F8968F89E268327B + +Set 2, vector#437: + message=437 zero bits + hash=3EC1C1C7854004273AF8126C939F1CBC1A4752D686C4C394 + +Set 2, vector#438: + message=438 zero bits + hash=DBB0B3A32D6D64A97FA5A369AB154DAF72C139459C6DB03E + +Set 2, vector#439: + message=439 zero bits + hash=ABE0D133C8F7D99DDBF5BF677C45E639F6ACC8DECE3E4D1B + +Set 2, vector#440: + message=440 zero bits + hash=A4EE394B2A208E9B0A74C6D57568E470F6E658C44689FC63 + +Set 2, vector#441: + message=441 zero bits + hash=8ACF5A7D9F485CF8118EE88EA7703A79726791A35418E2E8 + +Set 2, vector#442: + message=442 zero bits + hash=E49035A4751D0A51C783FE5C2AD28FC266B5716B9CB0EE66 + +Set 2, vector#443: + message=443 zero bits + hash=619E9240F0825D658FC11BF7FEBA29B4BF1DE81CBA839922 + +Set 2, vector#444: + message=444 zero bits + hash=5155E4A772C8345A0ACDC6D4D08B12DF21FB1363D04F00CB + +Set 2, vector#445: + message=445 zero bits + hash=FB331A6B32B8669EA5F3BCEAA32B06CFB0377C5CB7BBF955 + +Set 2, vector#446: + message=446 zero bits + hash=1937AB1E560F4BF2826B2E3342F90CF11D1090A13BF56C97 + +Set 2, vector#447: + message=447 zero bits + hash=5685188A6CE67610B69F2E78977FE9BF327384F3F34E19B1 + +Set 2, vector#448: + message=448 zero bits + hash=19208AEF976EEA1A1296AB46BB8519E4E35CC3D26D2B574F + +Set 2, vector#449: + message=449 zero bits + hash=B7C001DE41AD0EB237D223995419354C2854D1BDAADD24CB + +Set 2, vector#450: + message=450 zero bits + hash=09736469AF3DB080DDBEC218B19C0DDE7D1E200E27744BEE + +Set 2, vector#451: + message=451 zero bits + hash=9AA7BCF1582E4421CA66FEB80D6E803E15991F1C0D99DF73 + +Set 2, vector#452: + message=452 zero bits + hash=5BA881C421F8F98A382FA76B6C63C41EE53A7BFBB189D74B + +Set 2, vector#453: + message=453 zero bits + hash=96CE8DF6DBE539BC389741C68EAE9BB86C6AC98C827CC62A + +Set 2, vector#454: + message=454 zero bits + hash=2B06A2DFFD677E75AC0336108FAD6FE8B43F80E483141C4D + +Set 2, vector#455: + message=455 zero bits + hash=856A4F6AF406C1F663867E9176835214D9CB832D22A8DF4D + +Set 2, vector#456: + message=456 zero bits + hash=A0D74C6090806AE1B4A9A676950B940DC37D28F762AF66DC + +Set 2, vector#457: + message=457 zero bits + hash=1A57480F81096E92AFCF2B2D6F99AA159AB836F3AA88D5B5 + +Set 2, vector#458: + message=458 zero bits + hash=64990481CCABBA7EF3B2B9AB4DBB0153DE52D847D1D3E0CE + +Set 2, vector#459: + message=459 zero bits + hash=442F5F122950F44D0524953070C68BCDF53FF7D978579724 + +Set 2, vector#460: + message=460 zero bits + hash=54E0734814946AE8044479A73BD9D16EB86D8B980A58CB98 + +Set 2, vector#461: + message=461 zero bits + hash=3EC0CB725707E9E932DC2E47CDE7B3A625D3D7AFFCC695C4 + +Set 2, vector#462: + message=462 zero bits + hash=0966707C33FA06934CF0411349E0B34A7D4B8E676A6F332B + +Set 2, vector#463: + message=463 zero bits + hash=0EBA22FF036A6CEB3171A2EC4A594A763288CBB732B125A6 + +Set 2, vector#464: + message=464 zero bits + hash=DA1DCA0F6E414B6634ECF34DE132F3320BE35AC8D6AB0BBB + +Set 2, vector#465: + message=465 zero bits + hash=1E939670516BDD2388994FB1B3EC9936BBB29D3DC5282281 + +Set 2, vector#466: + message=466 zero bits + hash=5710E67498B2FE06EC199D82028FCF6912070F35E21A7CD3 + +Set 2, vector#467: + message=467 zero bits + hash=64C908483F58E3BB317384AAE8907B9318D9F159DBD34541 + +Set 2, vector#468: + message=468 zero bits + hash=C04313B59CA26122E79552FEEA3416E5FEFA1F52993DF8C3 + +Set 2, vector#469: + message=469 zero bits + hash=FE7DA75A8BCA322A2CD1E2239B0AD2045776ADF9AB16CF4A + +Set 2, vector#470: + message=470 zero bits + hash=6A1EBBA8217854DE4E61B81E3246E7908080CF4FB29B952D + +Set 2, vector#471: + message=471 zero bits + hash=3F08E23E82773EC74D03D1D19BF608D75D3012A679C7848C + +Set 2, vector#472: + message=472 zero bits + hash=49D948E0A5149A7B41F73C30B62FEEDBABA7DD9FFA9DB383 + +Set 2, vector#473: + message=473 zero bits + hash=BE9EDCCC18BC221B5440B367DCC31D2EFA77F01F05A5EBBC + +Set 2, vector#474: + message=474 zero bits + hash=3D9F6E880410A2AEB8974B7C2A8D31B062225035CBC35993 + +Set 2, vector#475: + message=475 zero bits + hash=73EEF67383FFD6D4728D27750644D8B8B34573D26FB1D15E + +Set 2, vector#476: + message=476 zero bits + hash=0F8ABDF2B9A98DFC98E52F2B25BC6D49F742FE8CAFC6AC5F + +Set 2, vector#477: + message=477 zero bits + hash=B6A47F78AFAC6677C5DFAF3CC70090794E6F36B12A04F8E4 + +Set 2, vector#478: + message=478 zero bits + hash=453EFCFC72DFB7A69328832BE24F6FDC03DE3CB41E0F084B + +Set 2, vector#479: + message=479 zero bits + hash=52643B42AC8D23B82F8D15704B0FA685F919BCEAF4A493E5 + +Set 2, vector#480: + message=480 zero bits + hash=95475FE7F5016A6FBB175EBF3B13EFE41FCFE9249586BB2A + +Set 2, vector#481: + message=481 zero bits + hash=DA7AC89CF91CBB2394F52DD8C851BB6A8139EC2E1740D2FB + +Set 2, vector#482: + message=482 zero bits + hash=3E1E886D303E4F8B4E22C14B0DBC31BEDED2A1F983C82ED1 + +Set 2, vector#483: + message=483 zero bits + hash=8AA2C1EBEFAE434A355D86F3303124C25F51B6AD51CD5E90 + +Set 2, vector#484: + message=484 zero bits + hash=B70E6A8BEF61A059ECB8534303D05DDA564A2E102DE9E1F8 + +Set 2, vector#485: + message=485 zero bits + hash=1F521182C7E9121DC069C1F0C825688EF75A11F8FFFE777F + +Set 2, vector#486: + message=486 zero bits + hash=34480B2F2B0BD9D23FC8F4640AFF4CE96FA837BC77739CCE + +Set 2, vector#487: + message=487 zero bits + hash=7209AC7B344407983A3B0944B025FBE188B88F256223DED1 + +Set 2, vector#488: + message=488 zero bits + hash=8AEEF6FEB5BF02F8ACC6430FEC5CC7858EEDF9C1DBBE8F09 + +Set 2, vector#489: + message=489 zero bits + hash=18802584E6C52DA289A61C4164070FFB53FAAF86673E721C + +Set 2, vector#490: + message=490 zero bits + hash=A6E3E4DA7CDF50842DFC2D944E701AB06180AACEF2B9AE12 + +Set 2, vector#491: + message=491 zero bits + hash=92816DC2ED34615CB496443B8B9B28502CD7D02F48D699DF + +Set 2, vector#492: + message=492 zero bits + hash=4D4C4B29D48A6158703135260B5333574F76286C40C6E866 + +Set 2, vector#493: + message=493 zero bits + hash=1E84279A19CA61D40E1F5197BD4DAB963A27F910F4D34776 + +Set 2, vector#494: + message=494 zero bits + hash=50C9010ACAFD193271C799BC07DB1831FD2132C0D9FD5460 + +Set 2, vector#495: + message=495 zero bits + hash=38760FE446BB63A6ACDCE9A69717AC29A7A04193E1299FC0 + +Set 2, vector#496: + message=496 zero bits + hash=0E425380B928052574D82A3F604162F3021361517560271F + +Set 2, vector#497: + message=497 zero bits + hash=2A74E081FB3B8C0F2012E1CD26DCA9502F11B2E2DFEBC98D + +Set 2, vector#498: + message=498 zero bits + hash=19C312C65129AEC09ECBDA2523C3623668A5883E1F0B3DB9 + +Set 2, vector#499: + message=499 zero bits + hash=005DDD8185F861CD77643932D00DB15E5D1E366F527CA344 + +Set 2, vector#500: + message=500 zero bits + hash=B53CF919B35C8D3C54FBD2ABF3285F354A569B10FB84D797 + +Set 2, vector#501: + message=501 zero bits + hash=5385AE84AA747F74EAB56891550D850AA8154BD82C04E51D + +Set 2, vector#502: + message=502 zero bits + hash=9CDFCFB1500A92E143FB1FB2D1F455539FBFBB918A6CB54C + +Set 2, vector#503: + message=503 zero bits + hash=CE2EF2314A52AF40AC697E942A88850562D8E6596F2CBD05 + +Set 2, vector#504: + message=504 zero bits + hash=A857DD168B22B65A6DD2EA8035C4EDC4B890453D14BA6052 + +Set 2, vector#505: + message=505 zero bits + hash=491271257C696C1F5DD5F48A6B77591486B7F90A63D704FF + +Set 2, vector#506: + message=506 zero bits + hash=AC8C3570DB6D358733E701C799BADB84319A41DAD02D1AAE + +Set 2, vector#507: + message=507 zero bits + hash=92D278265548B709549E112335FE56A885CCFC9126228C72 + +Set 2, vector#508: + message=508 zero bits + hash=4D22FC080CE4FC22AF165A13030CCAAB82D564470D2018A1 + +Set 2, vector#509: + message=509 zero bits + hash=EC1E62E3B5D8D5099CE0DAC5F4EEC04227B814FB74E1D1B3 + +Set 2, vector#510: + message=510 zero bits + hash=49A947C2E93398A60B4F4B942A02CA6E40F959ED170BCE47 + +Set 2, vector#511: + message=511 zero bits + hash=FE51BFD37834DF1FDC705F8D4977733B696E2C28792615D2 + +Set 2, vector#512: + message=512 zero bits + hash=33FF9966DDD692427A9BC4D611F3C74CF629A0544A1A7ED7 + +Set 2, vector#513: + message=513 zero bits + hash=4B96F09765730E4BD2F423950E42DB153CC4621DD9E3E52B + +Set 2, vector#514: + message=514 zero bits + hash=D04C8DDD186362D9E173584ACA2863DF9EB74CEB702B6580 + +Set 2, vector#515: + message=515 zero bits + hash=CB6B662D7DA39838FA98D1D0B3EF302F7C5AAD30A3EF9719 + +Set 2, vector#516: + message=516 zero bits + hash=303EAB880412E45B0E73F20F6B8A30AE9ECB8D010EA275A1 + +Set 2, vector#517: + message=517 zero bits + hash=500F3A3F9106BEFCED7EBA94833E43538F72AF465B611FD0 + +Set 2, vector#518: + message=518 zero bits + hash=941F7ED08356987364E25CD0D3B2D14FBCF2E3C109ACE130 + +Set 2, vector#519: + message=519 zero bits + hash=FBECBEE4188735B886D40E1E00CC4654E8F9841A58B38854 + +Set 2, vector#520: + message=520 zero bits + hash=759D79778FA748F8E828A568C45B7E2774A6052E0A4A06A7 + +Set 2, vector#521: + message=521 zero bits + hash=C36F70B07ABB4B6F238D460CE6F28636D4AE5AF314891885 + +Set 2, vector#522: + message=522 zero bits + hash=B9E4D16B5B00B755F179E9DE0DA7537BEA9FEC6304E97633 + +Set 2, vector#523: + message=523 zero bits + hash=F91A0A3779FE5C52B3D7FE1828B466728BEF769498A2DC9E + +Set 2, vector#524: + message=524 zero bits + hash=85694311FAC3110E162AEC1E7BE310FB12216694AB97C9CB + +Set 2, vector#525: + message=525 zero bits + hash=BF9655A0AE9E8F7E3CF3FC9D9428A2FE9BA415F6E2F790FF + +Set 2, vector#526: + message=526 zero bits + hash=E74BF06A00E844A3DACF96B8A0314D118210508968227333 + +Set 2, vector#527: + message=527 zero bits + hash=A1545BEB0C24A6FED11B30C6C0E200F0C86CCD9849EBC482 + +Set 2, vector#528: + message=528 zero bits + hash=93E4986EC1BAE0334662495E3261769214DFAB96C6567A12 + +Set 2, vector#529: + message=529 zero bits + hash=E7A446EEF954A261876BCAD3DF55A9087A4D5F754A38D8BF + +Set 2, vector#530: + message=530 zero bits + hash=90687664F0F0DD609B71CD19D7F71971C8A05BE234586121 + +Set 2, vector#531: + message=531 zero bits + hash=7EE44B7DC06792D333FD7863D364BEAE2CAC36445F381BF3 + +Set 2, vector#532: + message=532 zero bits + hash=23DFB3A3FA1B555B8851D3B4FEE5084FA4F8729B22FBF3C1 + +Set 2, vector#533: + message=533 zero bits + hash=5F2882A853996624C790F91A96BFE0AD3FA822305305BB9C + +Set 2, vector#534: + message=534 zero bits + hash=71CD8DD909F1473C92FFDF54839D15078DA83377BD3BB12B + +Set 2, vector#535: + message=535 zero bits + hash=57EED90F06FC7FEC2232B78FD370812F974C8406AB86363F + +Set 2, vector#536: + message=536 zero bits + hash=D50D44D48A7519B21C7ACF59DCD56066C7C328F680F2FB7C + +Set 2, vector#537: + message=537 zero bits + hash=7AEF9037C94EEE912FABE32B9261BC3D77F54EB49299DB31 + +Set 2, vector#538: + message=538 zero bits + hash=61DF45072DF01B439B6FDA3703C8012267C872E60DB16EBD + +Set 2, vector#539: + message=539 zero bits + hash=868D911B661C7B361E268A75D545655AB38C0CA7B592896D + +Set 2, vector#540: + message=540 zero bits + hash=A8CADDDF307239226CAE73144F6B3037E651E2DCEB25BAC3 + +Set 2, vector#541: + message=541 zero bits + hash=D151D12A79DB0B4A0C4F4AA8BDF42CB75F570F65292BFE2E + +Set 2, vector#542: + message=542 zero bits + hash=CE324FE20175AC4656EEDB92A052B2B9BC43CE30D54FD9CB + +Set 2, vector#543: + message=543 zero bits + hash=9D3891BD9906CCB4F5FE4A4835373D483DFAB350F684B2CD + +Set 2, vector#544: + message=544 zero bits + hash=6C240CDCC41A5DB56F7A88E25A04A2F3D10D33B6908D0F4C + +Set 2, vector#545: + message=545 zero bits + hash=27D66AAFCCF04A8DBF147A6F951865C8570BC445CBB67D32 + +Set 2, vector#546: + message=546 zero bits + hash=906B5C15BB63F7BF43A9D30F4059E46C3B28FFD9045324E9 + +Set 2, vector#547: + message=547 zero bits + hash=B6ADA6CC0B981BC8EDAC11280563197F8496F48B09A40BEF + +Set 2, vector#548: + message=548 zero bits + hash=29C5DCA8DE1538650319F259EB7A1E8A4AF694C0D01CCA90 + +Set 2, vector#549: + message=549 zero bits + hash=3C2DDE5BFE7DF9994A79B510CFF53A7A0DA6240D532771B4 + +Set 2, vector#550: + message=550 zero bits + hash=9E4D9FF06432059B15BD98F2737EA46C597EFBC519A40419 + +Set 2, vector#551: + message=551 zero bits + hash=00E7EAC89153E940EFF31B5CF2D10BFB9C893965BC4DC125 + +Set 2, vector#552: + message=552 zero bits + hash=D8581CF122C23E06A9A8781E6635113F76CBF21ECC520BE7 + +Set 2, vector#553: + message=553 zero bits + hash=C21E194207946496EDA1A5C76D1AA10BF3A8CF79B9951713 + +Set 2, vector#554: + message=554 zero bits + hash=8F9A758E67E3B8F45233DCB37EAE2C302BAD085B5815B241 + +Set 2, vector#555: + message=555 zero bits + hash=F779055B4EF3CDB07DB23AEFE6FA301B3C5338980A64458E + +Set 2, vector#556: + message=556 zero bits + hash=C1004D19844F3E08145989ABCD41D3C501598963E590C563 + +Set 2, vector#557: + message=557 zero bits + hash=82796EFB8F0CF9790A49F7B42AFC44DD94C7753AF4F64534 + +Set 2, vector#558: + message=558 zero bits + hash=4933BC26239BE8E544765B276B851DE85770A04CC25AA09F + +Set 2, vector#559: + message=559 zero bits + hash=82B9AA3A1EB92D8DF8233E5C17A7DC7B86BA6D98186A862A + +Set 2, vector#560: + message=560 zero bits + hash=1E763325671BEE3E17FD894D7A4E1405315004563BFAA368 + +Set 2, vector#561: + message=561 zero bits + hash=23F636DBD773680BBA7F736DC77C03A2BE53125CB51C2992 + +Set 2, vector#562: + message=562 zero bits + hash=2917267497B3600043AEA65E940DB70A12D8CF6F777DD61D + +Set 2, vector#563: + message=563 zero bits + hash=AC3DBDCF6DC91E68DA9D8F1454E47AB6CB3AB3CD7DF5937C + +Set 2, vector#564: + message=564 zero bits + hash=E9703CF79085CDBE599A2B7ABB4C299B52A6083BB17C7C64 + +Set 2, vector#565: + message=565 zero bits + hash=ED810920B896CF635E04E675493473431131ACFE68F01190 + +Set 2, vector#566: + message=566 zero bits + hash=DA0300E244937AF701F4D93B6F49F8EDAFD3BC89659F7443 + +Set 2, vector#567: + message=567 zero bits + hash=78CE95AD9CEE4FDEE7D5BD1F22A8547CEE7A6F7E31046145 + +Set 2, vector#568: + message=568 zero bits + hash=57B581CBF0EF91E38F4A306FFB3791A0BE6E1FA96BDE0703 + +Set 2, vector#569: + message=569 zero bits + hash=0459A0F3899575F22AF3635B651AA17C14CF707DA800F34D + +Set 2, vector#570: + message=570 zero bits + hash=A1764FEBCE8F1D47A054CAAE837142935C100B0497A50BC3 + +Set 2, vector#571: + message=571 zero bits + hash=35D1463594BC38FE8E9890ECAEB591F4A0DDEDAD0E52623F + +Set 2, vector#572: + message=572 zero bits + hash=2D556E5D05C09DF185E89EEC36B40B1AB54E592ECA35FE36 + +Set 2, vector#573: + message=573 zero bits + hash=699286EFF960E738A4777087F2885461376DDC597F323FED + +Set 2, vector#574: + message=574 zero bits + hash=E65D9ACBE1299E85DA75A95670458B74BFDFA9654A81F5A4 + +Set 2, vector#575: + message=575 zero bits + hash=61CC17A2E4E079F41E43FCF5DE1C60AB2110CD2B5B71C14A + +Set 2, vector#576: + message=576 zero bits + hash=0870537F7FD0A5F600E2B02B31878C2244F2E76C8D0AB421 + +Set 2, vector#577: + message=577 zero bits + hash=EBB03FBC1B5372398DFB8AFE2FB2548F60595438E9B2B2E2 + +Set 2, vector#578: + message=578 zero bits + hash=86B592895D7204B1CB5070D26A0BD648CF3E7B0C5F35E969 + +Set 2, vector#579: + message=579 zero bits + hash=4885C79193F110271B4C0896303EF7DF196A91BCCBB53EF2 + +Set 2, vector#580: + message=580 zero bits + hash=1F1A334D1DD150256E8BF56362CD08458BFE4A72D97E6088 + +Set 2, vector#581: + message=581 zero bits + hash=061ECB0BCA13550B390960E1CE630CBFE8CB1A39BE6BB4A7 + +Set 2, vector#582: + message=582 zero bits + hash=DAD6B19A11F00F92372CF4945AED62D01A03EBE8212755A9 + +Set 2, vector#583: + message=583 zero bits + hash=37FB327C0E10E98AF3F4DE96CB1DCFF3DCADFD74D4E461BE + +Set 2, vector#584: + message=584 zero bits + hash=6F1D28AA4EEF347CAE41FABBC528AE71345BAC83D6572BAF + +Set 2, vector#585: + message=585 zero bits + hash=4DB73B1AF685CA34735232CE78BCC57584925239319A85DC + +Set 2, vector#586: + message=586 zero bits + hash=8DD8ADEEC15B7367DA19F4372D18C09B8962B2C8F2CD765A + +Set 2, vector#587: + message=587 zero bits + hash=38FDDAC15B13380AA42328E094308053663B853EFB0EAA6F + +Set 2, vector#588: + message=588 zero bits + hash=6D4E2FE1F48AC04FC7BFF48BFD0F0A814BDB764B28D779A9 + +Set 2, vector#589: + message=589 zero bits + hash=7CEB13DB5C6BA7561E4E9E2412F73E9B1331B1EC219D2ECB + +Set 2, vector#590: + message=590 zero bits + hash=64284201527E4044950F3FB0FD65E6C6B83BD6FB98ADCC8E + +Set 2, vector#591: + message=591 zero bits + hash=4A80A80AB780D19BDD44E4E50FB4D29B174B7DC2D1A4F992 + +Set 2, vector#592: + message=592 zero bits + hash=704CE7D9895218DAABAF9BDF944F7901571D0C24873984BF + +Set 2, vector#593: + message=593 zero bits + hash=ED40F7F428A194454D181D9977DE498BCE127575B182DAC6 + +Set 2, vector#594: + message=594 zero bits + hash=161C0F62F34FB58C81153E3175705F7DC00C223F3D3E37F5 + +Set 2, vector#595: + message=595 zero bits + hash=DB4FC9CD5AD6DB3F5868220ABBC8770FA69968579BD8EC70 + +Set 2, vector#596: + message=596 zero bits + hash=18AA68867CE6B62222A6398DFD6ECC155B64455C8EE18B4A + +Set 2, vector#597: + message=597 zero bits + hash=403F31FDCAC2C7F26AAF02377359C838619EBE525C9FB4C4 + +Set 2, vector#598: + message=598 zero bits + hash=0A30CDA0012B2F3FDC6F81D277E9416BE934FCBCCFF5AEA1 + +Set 2, vector#599: + message=599 zero bits + hash=5646AB12B341734EF2B92E395D68F2CFA081018F748DB62B + +Set 2, vector#600: + message=600 zero bits + hash=1574D6AD7CABC7DFAEE1520289E0ED8B26DC6195C5F588BD + +Set 2, vector#601: + message=601 zero bits + hash=BF2D6B4034ECB4E1B19D9FD74DF01A66640B807487B7FDFE + +Set 2, vector#602: + message=602 zero bits + hash=65EF0FACC3599CAB31DE14CD30978C62469BF408E8EE7E8A + +Set 2, vector#603: + message=603 zero bits + hash=C051B31EE5F8EFBD8D772149E4494AA966F1CC612849386A + +Set 2, vector#604: + message=604 zero bits + hash=96A1FF454DAAEF40CBA155E4C3814920CD87D72D6566DDFC + +Set 2, vector#605: + message=605 zero bits + hash=1CC846F2A3304F3F1FFE730724C5EF0A402998A6F5BDBBA0 + +Set 2, vector#606: + message=606 zero bits + hash=8F0238DD571DBC3E7C6B079FD21A902ABB4572D49F16E6BD + +Set 2, vector#607: + message=607 zero bits + hash=25CA497BBE71AF5B77F724201654FAE26589D32067766A25 + +Set 2, vector#608: + message=608 zero bits + hash=257196F102E891E04ACD046CF099A2191ACE7F878B1C5CE2 + +Set 2, vector#609: + message=609 zero bits + hash=9C2AA68D8E43C5D63DD0383CFA5DF98580A31CAA553CFDF0 + +Set 2, vector#610: + message=610 zero bits + hash=1EDB7833ECD9D837E1D3A866A8BF52AEA81C80F5E1CA9A78 + +Set 2, vector#611: + message=611 zero bits + hash=F0D3453130D337B281825BE9B9E80556971CBA825A669ED4 + +Set 2, vector#612: + message=612 zero bits + hash=E9B864C9752F9C3A6AABCFAC7F5219BF08D96857BC8A45A6 + +Set 2, vector#613: + message=613 zero bits + hash=2E6FBA543331FE07692528EA9172B41BA7D69AB6FC95BF98 + +Set 2, vector#614: + message=614 zero bits + hash=D51D4BA457ADD451531E688D7CAECADA2DA2CA2BE7A888A3 + +Set 2, vector#615: + message=615 zero bits + hash=A965998E9B19A975C912C7E0B0BDFA26CA2DB7820CB653E7 + +Set 2, vector#616: + message=616 zero bits + hash=359F480A3475F89093F33289C3EDD28867C0E0F11AF79939 + +Set 2, vector#617: + message=617 zero bits + hash=045B6B436C15BBC09C1E761C2DC7FB7007C5866AEB095B76 + +Set 2, vector#618: + message=618 zero bits + hash=359924126EB52F43DF0FD1E185FEE3C49AFA9AB8E4D4D200 + +Set 2, vector#619: + message=619 zero bits + hash=F85CF1B8907763039EB3A6E99C04DC210A8BD7D40B3766B6 + +Set 2, vector#620: + message=620 zero bits + hash=D8EC8E67F43457BB035C39AB3359E25D91F9832D88CAEBE2 + +Set 2, vector#621: + message=621 zero bits + hash=DAA3EFB9DA1720220C00CDB06411DE36E7A6767E184F5EC6 + +Set 2, vector#622: + message=622 zero bits + hash=E99E114ABDA8DFDCEE9F404C6ADF620ADF313CAA04E5289D + +Set 2, vector#623: + message=623 zero bits + hash=B7F67BD650D55417BC48B4B54B32B34F7C3622DFB92C8FB1 + +Set 2, vector#624: + message=624 zero bits + hash=8CA6EF62DD4E1445C729E3FAFF0B57DF5ADA90D714B906F6 + +Set 2, vector#625: + message=625 zero bits + hash=9548A55DE683215EB74C181D8A991304D0355E5916283448 + +Set 2, vector#626: + message=626 zero bits + hash=B883B29D2E25487067E2AB464A6F9D79FB6A0A0D6B13FB98 + +Set 2, vector#627: + message=627 zero bits + hash=6FE13D9B04E2FB3AC67F9669C24B67EB32FC819BD787CEE3 + +Set 2, vector#628: + message=628 zero bits + hash=53F4C5EA1F79FD6BA0BDA032D47D383DDFF4BE7CC8120CE5 + +Set 2, vector#629: + message=629 zero bits + hash=F4297B82707D0F7D4C2728B79256EB06566CC762CF9F1D71 + +Set 2, vector#630: + message=630 zero bits + hash=74928E13AE397D48000F8D8DE156D25CACB3C7487F0DAAEF + +Set 2, vector#631: + message=631 zero bits + hash=B932F001044C33BDDC70A20E05BEF5DFC3443C29E6FC1E1F + +Set 2, vector#632: + message=632 zero bits + hash=D917B8C5CF18FBD88482F6754EFC9D308EBCAB912A609D5E + +Set 2, vector#633: + message=633 zero bits + hash=C4DE45FA612D7A1652E3115D5897CDFF44FEAA26C11A5A9A + +Set 2, vector#634: + message=634 zero bits + hash=1B4A90C037A477A40100FD47E787AC0469F5E9764C2ADF58 + +Set 2, vector#635: + message=635 zero bits + hash=DDE0B996955889E159C43D2D87E0137BD95429A51E9588EA + +Set 2, vector#636: + message=636 zero bits + hash=C9576BDB1387804FC5ABEF9ABF5E19143F1D22D438F8B987 + +Set 2, vector#637: + message=637 zero bits + hash=EEF71A3C9F19A10D437BB6FF6D33C3C43BFB24DA0E8A879B + +Set 2, vector#638: + message=638 zero bits + hash=4500DF1A8D677E594FD9A34DCCE8D79B4EB3D268C7358414 + +Set 2, vector#639: + message=639 zero bits + hash=6DAC60CA67ABD06CD6BE7262EEC26EB201EC49CB7494F9C8 + +Set 2, vector#640: + message=640 zero bits + hash=B3950A9D299A5A732CC0841F1EFAE62F3DB20A707B98F3F5 + +Set 2, vector#641: + message=641 zero bits + hash=F5B48FCE86CACD028E1943CC031160E2D1614773A9FFCE81 + +Set 2, vector#642: + message=642 zero bits + hash=B8516E8D5B7C83E4DAC48B5E711E0E0525537AEA3DD5E446 + +Set 2, vector#643: + message=643 zero bits + hash=008358A5CF4BB4A9D58CACE0C57910BB5D948DEF189D8C23 + +Set 2, vector#644: + message=644 zero bits + hash=277DC2D0229F2154CA794EFCCACE247098FBE00B20634484 + +Set 2, vector#645: + message=645 zero bits + hash=4B92E6489EE4303B6327CC868C42830B226B3FAC298E76C3 + +Set 2, vector#646: + message=646 zero bits + hash=361CF6E5F5A9770FAF28CDD4B12FE9A8E911381FDDC68E1E + +Set 2, vector#647: + message=647 zero bits + hash=BEE6F265F2AAC6296CE5F2F278FB8258C065FBBE68740683 + +Set 2, vector#648: + message=648 zero bits + hash=4112B496A4BA7C67F040A48A30C3F48496FDD3AD2A4A9E6B + +Set 2, vector#649: + message=649 zero bits + hash=59872FF734E631A2D1538DDC02DDAC2C785288A819A47EE8 + +Set 2, vector#650: + message=650 zero bits + hash=BD8F9769AD884851642141FAEDA3AC0A95EE321504D34B65 + +Set 2, vector#651: + message=651 zero bits + hash=AF017D1438C23D8D157B3479BF95180B203FA179B073A7ED + +Set 2, vector#652: + message=652 zero bits + hash=65BB58B117121271E32CF3700B1E51AE949116081D8F739D + +Set 2, vector#653: + message=653 zero bits + hash=6D4CE0B4EA29E7EEDCD2A8A817FA61E0BA340D3FB947087C + +Set 2, vector#654: + message=654 zero bits + hash=D841D9FFCCF37FDBDC9B32D49E30A30C98437EE47F8EBE87 + +Set 2, vector#655: + message=655 zero bits + hash=F5D25892E050EFBD462C15FBEC91093E4115931A973D7738 + +Set 2, vector#656: + message=656 zero bits + hash=D663C288232D8512986F0C2F37F20A764AFABF068F44CE62 + +Set 2, vector#657: + message=657 zero bits + hash=9683672998AEECE69DA6EBAE99201B719384956C9FA4AAE2 + +Set 2, vector#658: + message=658 zero bits + hash=F0E4243337B409002BC3B46B78C4D464A0928854B34DC6BC + +Set 2, vector#659: + message=659 zero bits + hash=BD8112AA5905013B1CD3175F8A9F133208D4A420CA898CD0 + +Set 2, vector#660: + message=660 zero bits + hash=41FD1545DBFE0DE81857E82A46778ABA68ED0D69AB768675 + +Set 2, vector#661: + message=661 zero bits + hash=B96DEEA03C7A08B45DD850D75D006372CC0FCD9A77FA0EF2 + +Set 2, vector#662: + message=662 zero bits + hash=12EFF5D746116A53ADD60B5DFEBCCC03615BE5D78F0279FF + +Set 2, vector#663: + message=663 zero bits + hash=58A429073D0E3086BEC5B9566F4FF7914B45506F8BB9675A + +Set 2, vector#664: + message=664 zero bits + hash=4B0292082184E5727B98ABCFD57197EE14AB5893E2CDD370 + +Set 2, vector#665: + message=665 zero bits + hash=93B745390D94BAA400A67A1DF78382541F5C663FB1E0EE32 + +Set 2, vector#666: + message=666 zero bits + hash=6348DD5F84B091F85C67FFEE809B8807A9AEAE9B0A20BDF7 + +Set 2, vector#667: + message=667 zero bits + hash=3F0AB3E9192A4117A013594EA6E671110262387A8F3CA73F + +Set 2, vector#668: + message=668 zero bits + hash=06119AC879360E6A42F96823D085F90990706370B6094F13 + +Set 2, vector#669: + message=669 zero bits + hash=33965CB30E14E89AC80BB2A870B9D02E2B30FFA52A93F436 + +Set 2, vector#670: + message=670 zero bits + hash=BEE4F2B5A0DE2D2253038491448C898894A35E1998DCC0BC + +Set 2, vector#671: + message=671 zero bits + hash=DFA8F315B46061CB5527C26054BB32FF6F5D3A548880B565 + +Set 2, vector#672: + message=672 zero bits + hash=9EAF05D45A302F909E6850E28AF8A88E51799E20EF75D0E3 + +Set 2, vector#673: + message=673 zero bits + hash=02614D90ADBD3A6B26802FE73D7E7DB53B1AE1E3A9A5DC98 + +Set 2, vector#674: + message=674 zero bits + hash=6167565F208D140C120C866B29D885931EB5DA0BE17DD614 + +Set 2, vector#675: + message=675 zero bits + hash=BCD32399A4B534A8C990069F302A737D1CA5E24C9AC4792D + +Set 2, vector#676: + message=676 zero bits + hash=7A4617C22861B6F8801C260191B05A006E3D0B00E409522D + +Set 2, vector#677: + message=677 zero bits + hash=42B26CB0B5A611E2DFE76250475F19FFEAEA0E8244BFD7C2 + +Set 2, vector#678: + message=678 zero bits + hash=4BD3B6E3CA54577ED9EF5167CC3407FF0DB621FC1C375E50 + +Set 2, vector#679: + message=679 zero bits + hash=A02BFD957CEE0446E5C79C45429269D4E0E70DC68A27B7D8 + +Set 2, vector#680: + message=680 zero bits + hash=AB8FBE9C09E9906200201F3AFCEF79AFF29267BA19C63A82 + +Set 2, vector#681: + message=681 zero bits + hash=11F7D467BFD00D8C1DBE090C98A8502C13EC0B7696D81FD3 + +Set 2, vector#682: + message=682 zero bits + hash=1648624081FE1221BB402CFA17C356F50C7622F98621652C + +Set 2, vector#683: + message=683 zero bits + hash=4F07EBC64AC586EA050E3E66FD9F4966725A7B5CE118F01B + +Set 2, vector#684: + message=684 zero bits + hash=AACDFFA77E7F5257E7191A102C5944050EB884D688A8A873 + +Set 2, vector#685: + message=685 zero bits + hash=73356100092067E4868AEB99D977BAE183483BA08510F26C + +Set 2, vector#686: + message=686 zero bits + hash=B4B087C878CF533B53E9E2E40DBC0015FC053E86F2FEB6B4 + +Set 2, vector#687: + message=687 zero bits + hash=2F102233F92064958C779EE8FE5CA46E9CB1D83CDE89BC19 + +Set 2, vector#688: + message=688 zero bits + hash=DB76DF9A0D2E9D21B57EC44C99653F59348981467EC2476D + +Set 2, vector#689: + message=689 zero bits + hash=9C83E73A6AB712FAFF97BA9D1BE7AE0DFE2192E83866005C + +Set 2, vector#690: + message=690 zero bits + hash=1CAF2A01197B8C4527F9DE9B401D01DB4741DF7DB0815CE0 + +Set 2, vector#691: + message=691 zero bits + hash=206ABD07A7BB966A917125B50010280CFF8A2ECBB2858CBB + +Set 2, vector#692: + message=692 zero bits + hash=6F56EC2AAD6D916CB0C9A4D6A9B4BA5CF3C19A04D6A77431 + +Set 2, vector#693: + message=693 zero bits + hash=EB71D191A03A31E3774EEA21CFC88290C021651780289A5E + +Set 2, vector#694: + message=694 zero bits + hash=ADF060551C405EFC8DDE00BF937F8E6862C956AE95648A8D + +Set 2, vector#695: + message=695 zero bits + hash=4937D383035EAB2CF617D1882E5B035B490761645414892C + +Set 2, vector#696: + message=696 zero bits + hash=0C2CCBAEB70C5C1F85FAFA01B1719F363D902716810F582E + +Set 2, vector#697: + message=697 zero bits + hash=DB38513D9F03C059319A626693344C99A51FFD0F1D9E773A + +Set 2, vector#698: + message=698 zero bits + hash=C4A8E8E8107EE307927DD8B3B063DA9267359D7D7EFAD004 + +Set 2, vector#699: + message=699 zero bits + hash=EE223A391D53D3EC9138BD4E2B7759FF03D27A6C24EC00D8 + +Set 2, vector#700: + message=700 zero bits + hash=2C8A96DCD659F9790CD521F779FBA97675B3F5C570E98506 + +Set 2, vector#701: + message=701 zero bits + hash=A007030ABCC28A1D55DE02E7EC28BCED18C1F55E6E159D69 + +Set 2, vector#702: + message=702 zero bits + hash=BF3F5D9BC21383F15DC81AF9753CFF1DE404B7ADF1599582 + +Set 2, vector#703: + message=703 zero bits + hash=2428DBA7C9182C307419B58D65F049B0F02E1FBED8E6BF7F + +Set 2, vector#704: + message=704 zero bits + hash=FCED365E31C7E4F3B06CB6720875A33E1AC45D047D071342 + +Set 2, vector#705: + message=705 zero bits + hash=14AF61CCC8414C6777B8693EC9C3DA0B2294B3618FEBB6AB + +Set 2, vector#706: + message=706 zero bits + hash=3152343DA08584541FB91884067C5204086FE9CF25045B63 + +Set 2, vector#707: + message=707 zero bits + hash=8284FFA336620D1DE090C50665B4735690414F41AF630082 + +Set 2, vector#708: + message=708 zero bits + hash=08B07367BA5021739FD246776978E355C20116C2781AFD62 + +Set 2, vector#709: + message=709 zero bits + hash=76AEFAAA65DD608452D2478DE0CC5F48D7F9DDA1E9CD1CF8 + +Set 2, vector#710: + message=710 zero bits + hash=A334673C6D865A267213ECA114753006A78C525D3343E5F9 + +Set 2, vector#711: + message=711 zero bits + hash=7853B7188EBB964DB741A309E51292CE330B3CA4B2267FD1 + +Set 2, vector#712: + message=712 zero bits + hash=2FEDFD926783A5C91D51BCC3228F2846243B95E5D858AF07 + +Set 2, vector#713: + message=713 zero bits + hash=152DCC608EEB4DB38A04A526F7D3ECD5C28DAF7A0FB46456 + +Set 2, vector#714: + message=714 zero bits + hash=C195E4B987F7017846663B11E6A2AA6D79AAB73495D87D93 + +Set 2, vector#715: + message=715 zero bits + hash=09EB427CE32D46B1A9F92AC1C71502F10C6AD2FF070B0240 + +Set 2, vector#716: + message=716 zero bits + hash=9AA0A0690672E35851D30B2F7D6FFC56ED63EBF01D6A0E0F + +Set 2, vector#717: + message=717 zero bits + hash=4433C2BEC783FFE50F52ACDEBBC9C819C45AF369E0D0D4D6 + +Set 2, vector#718: + message=718 zero bits + hash=31D2CF9E0335CC194288AB74CCBD8A2BBD91663069F290EE + +Set 2, vector#719: + message=719 zero bits + hash=131ECB9C325CB03E24B910F9CF32BD16DE34E47CDE793B86 + +Set 2, vector#720: + message=720 zero bits + hash=C1789746C0E04E42F2CEAA374FBCEDCFCB17AFB816D3D9B5 + +Set 2, vector#721: + message=721 zero bits + hash=AF98F44129C560CD2DC5C8F869CC2A753905AE872B7577C8 + +Set 2, vector#722: + message=722 zero bits + hash=3398368F41E18B1B52BAD154653A13C93228BC2C23DCE276 + +Set 2, vector#723: + message=723 zero bits + hash=2FF0F3450C1AE1D7A8DCB83B55B5717B0204E45754095825 + +Set 2, vector#724: + message=724 zero bits + hash=A157556C3CEB0EB035F44C3344353870F9C8276500E77959 + +Set 2, vector#725: + message=725 zero bits + hash=040298A47B48230FBD0422E3BC671A42BBC7018293DA7902 + +Set 2, vector#726: + message=726 zero bits + hash=A65BFD919FC4C8D0D1E063252D5693CA0DEEC9ECAFFA281B + +Set 2, vector#727: + message=727 zero bits + hash=EFEC1B9E91663F15DF8057375F36BB4D0423BC3AF3084D6B + +Set 2, vector#728: + message=728 zero bits + hash=C055A3A9EF84BD96AEBAE31C08B74BA22BD2489C70D25672 + +Set 2, vector#729: + message=729 zero bits + hash=8359437F0D35CE717001F094EA6FA517A109E1622F75BCB6 + +Set 2, vector#730: + message=730 zero bits + hash=57447C4630A238A0776AE4EAF12C356A81AF2CB0CEA59DE4 + +Set 2, vector#731: + message=731 zero bits + hash=82C7F5A1D12EBB2E744EC2ABB3AB3626A15080FB7EA91D96 + +Set 2, vector#732: + message=732 zero bits + hash=FC6A36281D976C7EFAED0B3711AFB25C4C527CBF07C94FB0 + +Set 2, vector#733: + message=733 zero bits + hash=4762DE286A18A73A42AF4D5117AD8CDAFC2339B6FDB8F2B6 + +Set 2, vector#734: + message=734 zero bits + hash=907F74828C567DA898A6AE1B04C7CB2110E899B97B87F39A + +Set 2, vector#735: + message=735 zero bits + hash=8020EED49FE1CA20317563B1BBA5E0595E443F04D34EC230 + +Set 2, vector#736: + message=736 zero bits + hash=AE1AEECA1373D4348E4EDC2B7F393A8F44A351AA952AD7F7 + +Set 2, vector#737: + message=737 zero bits + hash=665B2A1A727E57E6C01EC695D645428CED0F13E98CADF899 + +Set 2, vector#738: + message=738 zero bits + hash=63221BA15C1E91FAC1C92F394250E0AB0D0A790945A36EA3 + +Set 2, vector#739: + message=739 zero bits + hash=DE7D9673C1D22D88EE65EB131D4B791107649352403D9F5E + +Set 2, vector#740: + message=740 zero bits + hash=3F1197F078ED576BCA4AFF2884F36C90DAAD8AE2D4A44FB2 + +Set 2, vector#741: + message=741 zero bits + hash=E1E07E5FF47BB806D94B4F86B5DF98FCD540016CA93C0122 + +Set 2, vector#742: + message=742 zero bits + hash=F24B252235C2BFE8B59C65328258B8117A1A15CA040DE2D7 + +Set 2, vector#743: + message=743 zero bits + hash=50AE2A92F034581CFA656DF65C237BD771F44C2BF6714902 + +Set 2, vector#744: + message=744 zero bits + hash=60CA04458514989969B5D3A1537F226CB54E3FCE9CC9B134 + +Set 2, vector#745: + message=745 zero bits + hash=89DDADE87F6D5014D5511C5F9350617633DDE5739F877F2C + +Set 2, vector#746: + message=746 zero bits + hash=F236602DE10AF723E14CCB421FC91353F374CFF4AF79428E + +Set 2, vector#747: + message=747 zero bits + hash=657A49B0359DD9ADB5482AD898F920A937CCE04569E6C5C9 + +Set 2, vector#748: + message=748 zero bits + hash=84545DCFAFFB4D820D3AFAA6A34187814476953F7DEFDB52 + +Set 2, vector#749: + message=749 zero bits + hash=CC195221D0ACFBAFC4EB3551744F111DF7C064D56E5A48D3 + +Set 2, vector#750: + message=750 zero bits + hash=D73DBE7C4D4C83460245904D1359D90CAF8CA0251289838C + +Set 2, vector#751: + message=751 zero bits + hash=F045F83ACF0B3DB819E091A4A5DAC9BF6D7A3C1F9763EF62 + +Set 2, vector#752: + message=752 zero bits + hash=20E29A4A4C36D7C2BADE368564765EE0353709CE47D0E36A + +Set 2, vector#753: + message=753 zero bits + hash=CF58C29D18E29B6C5F0292CDAF698E5366CA1B3B7BFAD78F + +Set 2, vector#754: + message=754 zero bits + hash=DEAD60E074F4A64FE5A1BCD0DF0E930259679600EC2BC337 + +Set 2, vector#755: + message=755 zero bits + hash=ACF6CE7239649EF568A369356C76BCD3C16D40FCEEDDD215 + +Set 2, vector#756: + message=756 zero bits + hash=B418B4CC233F0A069208C6E4FE15007B5EE98C0F6C351068 + +Set 2, vector#757: + message=757 zero bits + hash=18D91DB63FC3849F9FA924125FE8EA1CF31110432C3A5DC2 + +Set 2, vector#758: + message=758 zero bits + hash=FEFAF23907DAE6D86C3E0944B610DAD8016BA01609E24FCA + +Set 2, vector#759: + message=759 zero bits + hash=11130B384A56A218C1CCCD837B1675C3E8ECE715A06E869B + +Set 2, vector#760: + message=760 zero bits + hash=8CE7840450B26DE74B798056D30584DCC436AD79B061729D + +Set 2, vector#761: + message=761 zero bits + hash=DF5F29EB44234654485C7B4AB2BBFAD827F6F6F92C562C78 + +Set 2, vector#762: + message=762 zero bits + hash=F199E5A725E25CFB226D5F52AD18FE7DA30C2380DA46B2BE + +Set 2, vector#763: + message=763 zero bits + hash=AA227D0D6C56A7CBC6AD53BFE99F8AF609A4BA5E1C19401F + +Set 2, vector#764: + message=764 zero bits + hash=F367C625CC2644592F959095E9CBB2C160FFDBE609A3BD42 + +Set 2, vector#765: + message=765 zero bits + hash=9FABD207618D722C7F433137782D980D2CE9764B4301BC5C + +Set 2, vector#766: + message=766 zero bits + hash=E7DE2BD8460EA22B677998007C30CAA11099163DEFD85AAF + +Set 2, vector#767: + message=767 zero bits + hash=CB722C247F8FCE7459DB84E5F053A068468AB3327E63D11C + +Set 2, vector#768: + message=768 zero bits + hash=05D2A28308C44536C591DF21B02AB542AF982B81A4C5E129 + +Set 2, vector#769: + message=769 zero bits + hash=E008DFE9BED4937EC85950408428D3A07ADB66EEDE29272F + +Set 2, vector#770: + message=770 zero bits + hash=87CBEFF490C4CB52ADB75B9EDCD63B29D07AD01CFAD5F5EF + +Set 2, vector#771: + message=771 zero bits + hash=C32A917FB42DCB857883780CEACE71F53E488EE57F63A0D0 + +Set 2, vector#772: + message=772 zero bits + hash=0C828CBF002F9890E23543BCE470C91C4C5110890CD5258C + +Set 2, vector#773: + message=773 zero bits + hash=7463E6B410CAA6A1B100BC6EF5E146239285A43F07518403 + +Set 2, vector#774: + message=774 zero bits + hash=411AEEF7B2999BCAB60CF7154867107E287690AA3121840A + +Set 2, vector#775: + message=775 zero bits + hash=30E718A0B54F911608ED9981A3670C8317B87053C55ECE82 + +Set 2, vector#776: + message=776 zero bits + hash=196ACD3484E2F5FD51AC0CC667596AB0E764936C37A345B7 + +Set 2, vector#777: + message=777 zero bits + hash=D322494FB91A4C307680125CCB5CC650AE5CD82DC730C659 + +Set 2, vector#778: + message=778 zero bits + hash=09029C785ACF04B41E0ECAC2823F8A5F11BBFE240C0EE944 + +Set 2, vector#779: + message=779 zero bits + hash=BBD6746F03B71CD58EC1342070EAD8727EE7003E192353FD + +Set 2, vector#780: + message=780 zero bits + hash=CFA3DB86B27201D0EF3008C9FCB88A182EB17C9A44F16886 + +Set 2, vector#781: + message=781 zero bits + hash=C95132471E4B7C7F7167EB9C7FA7C92CD767FD1BA6E1FD6E + +Set 2, vector#782: + message=782 zero bits + hash=489755E829DE6F9AB28BBC63089B37B56A44A5B19AC4BAB2 + +Set 2, vector#783: + message=783 zero bits + hash=8FB95BA35D5235D068E7F6CEB31DF7A51011F441BF7AED4C + +Set 2, vector#784: + message=784 zero bits + hash=C4F29A86A5415A0086FEC47CB3D46A71E8D224880657789A + +Set 2, vector#785: + message=785 zero bits + hash=B9397395E2574B004A64262A36C1C3319F9E28EA6413F218 + +Set 2, vector#786: + message=786 zero bits + hash=B6F26251B5CD3E3178C1B31CE0B9F61F5102AB7B53C954EC + +Set 2, vector#787: + message=787 zero bits + hash=E810E857E06A6560B0199973C59B0DC075008BD64F9648D8 + +Set 2, vector#788: + message=788 zero bits + hash=71B0A84B1212BAE33430BB15DEA1F86C78F8B5BCF967CBD2 + +Set 2, vector#789: + message=789 zero bits + hash=1E4BD3ECBD1B66E0EB42DDA29826A417FEB5D7E00B9751D2 + +Set 2, vector#790: + message=790 zero bits + hash=D0B541027F58642956E576EBFF19E1698613C167BAC09C8C + +Set 2, vector#791: + message=791 zero bits + hash=0E9168F36ADBAD5D084FDE06A265A75FE57D31A6E080BDF5 + +Set 2, vector#792: + message=792 zero bits + hash=C5AD956C7D06EC8651665176733FB2EF0D01BE7E81E0F775 + +Set 2, vector#793: + message=793 zero bits + hash=AE676E722D416F9A2C9A71115F78373049A37A2DE230924B + +Set 2, vector#794: + message=794 zero bits + hash=D1C7A48C6D714D3A81367C7040778549C0C531E9E9FC6BCC + +Set 2, vector#795: + message=795 zero bits + hash=4D8D72ED5DC1121BF5E700CF603C5AD0FF764B71A9468AAA + +Set 2, vector#796: + message=796 zero bits + hash=D0A4BAE93E55BE9C87D6ECCAD8F6F451E2CF7A4AD30A4858 + +Set 2, vector#797: + message=797 zero bits + hash=24478EC1D846BF2016FE3FF161BCCA7B9E99EE6DCE14EADA + +Set 2, vector#798: + message=798 zero bits + hash=3973FC4140ED0FFA38B892A3ACCAD5F5FCF726C57393E8B8 + +Set 2, vector#799: + message=799 zero bits + hash=D25EA293CAE971BC11615FBB4299E67659CB765AD4F7C69A + +Set 2, vector#800: + message=800 zero bits + hash=A5A54E12A9538A158E78AE09896DCB2CE31F14150625E615 + +Set 2, vector#801: + message=801 zero bits + hash=5124551BC6F2EC932AC5246C6E36578F9FE89FD64DD8C1D8 + +Set 2, vector#802: + message=802 zero bits + hash=12D12E9DE6479E5B7772EFF1AE04F70DD17B22FAC4781CDF + +Set 2, vector#803: + message=803 zero bits + hash=5EE944FBC71C076EBE758FCD38722BC6B6FAA93949E68C06 + +Set 2, vector#804: + message=804 zero bits + hash=234514C6E1A1F394E5D068A09B3E840815C20E68CFE2ED2E + +Set 2, vector#805: + message=805 zero bits + hash=F8254FBD3D55BCB072A6F89F5294CA43CE9BB07E1A78BA43 + +Set 2, vector#806: + message=806 zero bits + hash=06952E7A2A1D9560B8ED418EBEA56366CF7478030F9E9A31 + +Set 2, vector#807: + message=807 zero bits + hash=5DA678192BBBC15116608163F70962873A4276AD547CF1E1 + +Set 2, vector#808: + message=808 zero bits + hash=239045220EF064D13637D503A6079EF21B5F2D02CF98FA5A + +Set 2, vector#809: + message=809 zero bits + hash=B8A86449A4F75A8A7ACEC855AC94A658105908F76432D70D + +Set 2, vector#810: + message=810 zero bits + hash=739D8FD418243AC2A794B3F771F7C6BB0870CD56F5D854D8 + +Set 2, vector#811: + message=811 zero bits + hash=2E545E4E97B118AB88FA22A0F09B751F4989B042317BD596 + +Set 2, vector#812: + message=812 zero bits + hash=F3CE9D17AA396115C25DB18F5EB7A36AEE946054E18EE78E + +Set 2, vector#813: + message=813 zero bits + hash=7200C7E935E5FA40CAFA8E9CF67FCE3134F82062AACF0584 + +Set 2, vector#814: + message=814 zero bits + hash=1E4C55A649C5D6D0ACDE8AC5AF9FCD871DCFA177A46340BB + +Set 2, vector#815: + message=815 zero bits + hash=1C56193D6E23AC74F0DB64DEE0913C24CDADDFFA323EC4A4 + +Set 2, vector#816: + message=816 zero bits + hash=AAEA04D2B11931D58016A9B68B3FF543C7BFD87823EA6ABA + +Set 2, vector#817: + message=817 zero bits + hash=AB067AA6F2621A518559B29898E3BC9B7E74A94B671ADDF9 + +Set 2, vector#818: + message=818 zero bits + hash=5BFC790896C34A050D05230E17F96C32DF60824419A0AA5B + +Set 2, vector#819: + message=819 zero bits + hash=19237CF766ACF6F09833CB64CF7D3DC666A1A6C3DE598C86 + +Set 2, vector#820: + message=820 zero bits + hash=CC94EEE6D6CF47CF5129A0E7B3856475A9F699FC8C253322 + +Set 2, vector#821: + message=821 zero bits + hash=9F8DC736AA8DBDB3D2BCEC81D713B719DA7A11E6C92532D2 + +Set 2, vector#822: + message=822 zero bits + hash=2BD7EDA5ED32D239BF16116580A245587869587C0D5A1E15 + +Set 2, vector#823: + message=823 zero bits + hash=30CEFBEDE0899440BF1887EFE92330AFE13159B25DC59897 + +Set 2, vector#824: + message=824 zero bits + hash=37838610BB3944FB3DFBB14B95A4007705B3773148E58AC3 + +Set 2, vector#825: + message=825 zero bits + hash=875F3A4CC0CCB75CFD9FBE685AF3C891B8027EADEF0A65AA + +Set 2, vector#826: + message=826 zero bits + hash=B2C3F1FFE0499C1CEF7FA485F3B36EC937FFBCD6F45B657D + +Set 2, vector#827: + message=827 zero bits + hash=0ABA97F082C6AD63E0E0D5FF4925B04D47E55113240EEBEE + +Set 2, vector#828: + message=828 zero bits + hash=C40D0FB374F55FF2C4A524662E65AF04EBBA9F1F2FE411EA + +Set 2, vector#829: + message=829 zero bits + hash=94AA7C83CE1A5A313247DA3D04E7F5E913E133D10C0F06E3 + +Set 2, vector#830: + message=830 zero bits + hash=71F556E9C2C6AFD5CE110ECC548B4E2C61180A6122269DB3 + +Set 2, vector#831: + message=831 zero bits + hash=DBBD13DD68AD0172A852492EFD3C5BA42AB6B2AB4E9084C5 + +Set 2, vector#832: + message=832 zero bits + hash=3DE1ECB5FEC022C7CF8B4CF4AFFEE41D85648EAEF6B0F5A7 + +Set 2, vector#833: + message=833 zero bits + hash=8B926ED6062F9C67DF686D1CCDE0ABF93A60694B64D6BE28 + +Set 2, vector#834: + message=834 zero bits + hash=0C45ECAC55510A994395BB0643D7F94717F3ED533CBADA70 + +Set 2, vector#835: + message=835 zero bits + hash=4385B3786EF3342D0A4119588B89AE8048C67E97101249F6 + +Set 2, vector#836: + message=836 zero bits + hash=571BFA74B68DEC571B7DAAA0AA684FCD54D816006199BBE2 + +Set 2, vector#837: + message=837 zero bits + hash=893ACC7C5E053D2D6A53B019A42151D23534D1F0BF24D89E + +Set 2, vector#838: + message=838 zero bits + hash=59F9983726C300CBB7F6575F3345473DFE04318CCBA1A7D1 + +Set 2, vector#839: + message=839 zero bits + hash=3D21F69E1CFA3112A0E3CB2534769547D13308C5F3DA3F17 + +Set 2, vector#840: + message=840 zero bits + hash=40224B9C7ECBBB69D1A5E0A3A0F249315AE1E7DE859FD763 + +Set 2, vector#841: + message=841 zero bits + hash=AC5F6B5B407E7C09F0E09240755E8D96B9C1E4DEE228506A + +Set 2, vector#842: + message=842 zero bits + hash=75175389FA135492A540664C8544C8B4A8AD19CD685AF350 + +Set 2, vector#843: + message=843 zero bits + hash=8D33C870B0D3B61E73E8A66E03ECF8067162384298AE03AC + +Set 2, vector#844: + message=844 zero bits + hash=05E46C37F3CB05BCC68D7A2EA1AED4B5618FD09C6E8B00C2 + +Set 2, vector#845: + message=845 zero bits + hash=5D741AC904507F1BD7F6264D7373A54FD2DCEC28839EE7A8 + +Set 2, vector#846: + message=846 zero bits + hash=369884F0A6F7146697435EA6E862EB39B10ADF7C703CFBAA + +Set 2, vector#847: + message=847 zero bits + hash=9712CB31FB386198EB78EF9023C5BD1A1081EE72B7AC0AE2 + +Set 2, vector#848: + message=848 zero bits + hash=7EF8F229B824EA82F8E8834E799A67A0B946086BD9AA582B + +Set 2, vector#849: + message=849 zero bits + hash=27C15AE37F283241AD953233A831FCB48B249B16831D24B6 + +Set 2, vector#850: + message=850 zero bits + hash=374FDF3468856A576B72D25CBAC7324D592ADEF50F0CA40A + +Set 2, vector#851: + message=851 zero bits + hash=7250739EE5E44B428B9F2F8B1D43352AC1E5A54083720DB4 + +Set 2, vector#852: + message=852 zero bits + hash=886B83A6BFA8D5F608BD5E625C697BD701CB3D34B7C6E19F + +Set 2, vector#853: + message=853 zero bits + hash=F0928A7B6B65CC3CFC01E034927D5B4094BA04E66A3BFC91 + +Set 2, vector#854: + message=854 zero bits + hash=E8DBC10EE210F168697B6B8C7E866B0564733B597499B8D6 + +Set 2, vector#855: + message=855 zero bits + hash=FF6F1669656A8924546ED215700F91A4D511191935690D6E + +Set 2, vector#856: + message=856 zero bits + hash=2543ECA4058C02EFE62E2131E9A7627D6DCAA6C51A13A517 + +Set 2, vector#857: + message=857 zero bits + hash=2A41B4A4E6B7621EC424266E7CEC019AD114D717A75B0B23 + +Set 2, vector#858: + message=858 zero bits + hash=27AEA8910BA345F1FEF67192E962B96C08FBE9536073AB65 + +Set 2, vector#859: + message=859 zero bits + hash=42B666685F8B3F3B4628E7B689E261F7C2B3217E9A1A4645 + +Set 2, vector#860: + message=860 zero bits + hash=CD47B41322DCCEB5F0734C0CBA55201621929FC16E3D8FF8 + +Set 2, vector#861: + message=861 zero bits + hash=A0370B7E0E7FE2FD7AF27B32E11436DBE60D85B6F0B085DB + +Set 2, vector#862: + message=862 zero bits + hash=B069DC359CF738F285FFF7AB6EB79F1F58F5B3693CDFF769 + +Set 2, vector#863: + message=863 zero bits + hash=C59EA69553AA4A97E01F077AA7C26644CAA01CA97C74A3FA + +Set 2, vector#864: + message=864 zero bits + hash=51E2B3A3D56D88BDB4F77CEAC0D146B08C269EB50D7914D4 + +Set 2, vector#865: + message=865 zero bits + hash=7AE40B10C2564C0F975FB280A9908C01ECB54A44D4A1725A + +Set 2, vector#866: + message=866 zero bits + hash=FA547020C95380FABE2D98E5DB91587C938BC4A294F97DD5 + +Set 2, vector#867: + message=867 zero bits + hash=5F62DE8B683CF0257D589B5BF067E2C5E63F805728C5E566 + +Set 2, vector#868: + message=868 zero bits + hash=76597114099D0FF16C78AE64E62E4E6659891A288E86BEF5 + +Set 2, vector#869: + message=869 zero bits + hash=EBE402FB0485FC6D9F4232FAA19577CBD08B75ABE182D9E2 + +Set 2, vector#870: + message=870 zero bits + hash=01AC2D59DCEC9AD8C06A9591F71780DD2E9F0650AF23A079 + +Set 2, vector#871: + message=871 zero bits + hash=FED2A77F2EDBA371ED74CEE7CD59D4A39CFDCC6E4F3B79A0 + +Set 2, vector#872: + message=872 zero bits + hash=9A3A264F48D2BC4B08671B0D6EE58B4E0E87D19CFC561738 + +Set 2, vector#873: + message=873 zero bits + hash=37929473A58993ADCAC09ADAEBF6A352602126C8870B12DE + +Set 2, vector#874: + message=874 zero bits + hash=194FBB4CC683604008A42929F96E7C3BB2A48F201A8019AC + +Set 2, vector#875: + message=875 zero bits + hash=F57B61B59215B570F17E209F5C06EFB8FE1072053DA57403 + +Set 2, vector#876: + message=876 zero bits + hash=3A9589D456EEE28C372675DAA9F364F8034406B8C072D86B + +Set 2, vector#877: + message=877 zero bits + hash=CDA1DB3AD4F3369F0F597EE3D925C39E55CBB5913FAC51E8 + +Set 2, vector#878: + message=878 zero bits + hash=9AA3C9D6EB62026B8B12C3032709E52CC782F0FD0BC44321 + +Set 2, vector#879: + message=879 zero bits + hash=821D1BE303E8FFDDEBF59F684D40EC98714A4CB5657519EC + +Set 2, vector#880: + message=880 zero bits + hash=F8F8F7095F7FF1111811FB2B63F431B529CA740EFA9A3350 + +Set 2, vector#881: + message=881 zero bits + hash=57E6E8CBBA61AABAE7E0459C5E8955953C3A5C9F414F2B53 + +Set 2, vector#882: + message=882 zero bits + hash=22FE84FC8E699E217807F5D0199F808E3A32DCFF3158B6E2 + +Set 2, vector#883: + message=883 zero bits + hash=AE44F6A36900C52F2444681BA484DFCEACC7DFD0D6A2D7F8 + +Set 2, vector#884: + message=884 zero bits + hash=40D20C00E12583B87DD2214946B05A3F33ABAA7D9EEF075D + +Set 2, vector#885: + message=885 zero bits + hash=8844C01D1EF1FFD58BE4BE7412A974BC0E35C61EF3FDAB7B + +Set 2, vector#886: + message=886 zero bits + hash=5F7D81FBD5A219998ABBE4A40AD15810E00E0A1A3D2DC9E7 + +Set 2, vector#887: + message=887 zero bits + hash=44B22F004D7A8B08B5794E3D94B07CAD00EFDDD87D0A68B6 + +Set 2, vector#888: + message=888 zero bits + hash=E0BF4F81FB633EBF0092E6AD4EC8B6834A85DF4F639F94D0 + +Set 2, vector#889: + message=889 zero bits + hash=E8BDFDA08887ADC1BB6F240FB185B8D0A375921AA82B6694 + +Set 2, vector#890: + message=890 zero bits + hash=440253D277F9E97932FED4DE240EDF6F74BA373135B480EA + +Set 2, vector#891: + message=891 zero bits + hash=549F18592C1C6417ADC0620491AA0FA727274DEBE495F7BA + +Set 2, vector#892: + message=892 zero bits + hash=FAAED9A8C586879E8AF8F1DEEB4F0EB7A681C58D9BD69527 + +Set 2, vector#893: + message=893 zero bits + hash=CD495EAF48EDDE5984C3CAFE2CE297A2C174776DC3AE3825 + +Set 2, vector#894: + message=894 zero bits + hash=EE1EBC7F5A326FE52B44F4A0DE6FABDA8E9D10EDF962EDD6 + +Set 2, vector#895: + message=895 zero bits + hash=4995C15FAF2F80DA43B819E776E5D31FFFB3A9FCDDAA8B79 + +Set 2, vector#896: + message=896 zero bits + hash=114BD7F8FCA026BA9874DD79174EA1FB7275B8C7F2042871 + +Set 2, vector#897: + message=897 zero bits + hash=A52EB64277C3E193C1E4D4EDCBCB29206040810A2034BD41 + +Set 2, vector#898: + message=898 zero bits + hash=7C937ABFA87B4E1AFECF2DADED584AB56BEE6BAB335704A0 + +Set 2, vector#899: + message=899 zero bits + hash=054DF15BBC2276332B819212A1D4D9D7EFBB87B586B48FB7 + +Set 2, vector#900: + message=900 zero bits + hash=A474DB87513795BE16E2A83826E8BD6172DADC5580D8892C + +Set 2, vector#901: + message=901 zero bits + hash=A33889112918869C07E383A0493A0D88782E8FB1283BED4A + +Set 2, vector#902: + message=902 zero bits + hash=3622E243F9BCD0C6AFF42988B9C7FCD35CBF9CF5FF311441 + +Set 2, vector#903: + message=903 zero bits + hash=A2502BF015FFF87E14CEC12BB52150FE301EBBB54DF91033 + +Set 2, vector#904: + message=904 zero bits + hash=BDE5124EBA58CD1929DD63E9A4A987296D93E78378BA7E21 + +Set 2, vector#905: + message=905 zero bits + hash=5304DFAD2AF734333B82743AE8AA10A647A4BB4A95611CE5 + +Set 2, vector#906: + message=906 zero bits + hash=368E76B1FFA704BB5EC0143FAF7B1EC0264B02F2471A8A8E + +Set 2, vector#907: + message=907 zero bits + hash=0EE1C9FA0C3E4D3D261B4185AB38E58E35CEA8C7A5D7776D + +Set 2, vector#908: + message=908 zero bits + hash=9CD1B0D3AF7F4A697DB4C0705C39E6E06EB81A51CDA9ED3D + +Set 2, vector#909: + message=909 zero bits + hash=ACDF3C6AEEEA9185245D5B4D7BC8526698DF9670B397A8E0 + +Set 2, vector#910: + message=910 zero bits + hash=71012A9F082EA541C3762DA042F16F0418F03A069BD80CA0 + +Set 2, vector#911: + message=911 zero bits + hash=D9C7C94329B348C411E21750E7B5E0188ACF677884213C8F + +Set 2, vector#912: + message=912 zero bits + hash=FAA1FA47DEDC888043BC35BD97288C3E3E8702E3790A5ED4 + +Set 2, vector#913: + message=913 zero bits + hash=0389078E174E9EE8095FAD41BE4891D4D6121F63665C9BC6 + +Set 2, vector#914: + message=914 zero bits + hash=8001C890229E8AE714682AD08CD11BC25B883E6D35C1AC2F + +Set 2, vector#915: + message=915 zero bits + hash=00D3DCB71064BAEAE25CFC1317B3665ABA285DAAE8B1A5E9 + +Set 2, vector#916: + message=916 zero bits + hash=7BA68B7CF5A508B49F57BCF8A8A9C96E47BE2A32E8C7F3D3 + +Set 2, vector#917: + message=917 zero bits + hash=95312E89F5ABD005D8CF5D763A9AF0E7A964E3E2D5D5963D + +Set 2, vector#918: + message=918 zero bits + hash=A2150E7770743F20AB099942FD07BC6C78E32D04A6A81E19 + +Set 2, vector#919: + message=919 zero bits + hash=9B769E4C244D0479991D741C0715557488BF92CE0EE1F487 + +Set 2, vector#920: + message=920 zero bits + hash=4D0016CD63CCB3C917A9CAC0A656ABF1BF1F79A42D9FB4E5 + +Set 2, vector#921: + message=921 zero bits + hash=3FA979D7CA94A5673277A81A55B8DF2AFEA1BB03783CF6C9 + +Set 2, vector#922: + message=922 zero bits + hash=B0F82E85D9E9BF74299A59185845B5AEB967F1A84BF25D45 + +Set 2, vector#923: + message=923 zero bits + hash=142D54F33AA60E3784C0A71FE3E89CF00D1F45050F86C00C + +Set 2, vector#924: + message=924 zero bits + hash=336D2159C49EB770BDD020AA74A876FEE149B2C076AB1901 + +Set 2, vector#925: + message=925 zero bits + hash=B4F923DB1BD7859C158079CA3C67D195769E89E7BEE332CE + +Set 2, vector#926: + message=926 zero bits + hash=9D00F289C962B1266C7597B9B12975F244DA8B9F0422794E + +Set 2, vector#927: + message=927 zero bits + hash=EF69B5993A01B037965F2834C944785FB4D6050CBFBF65B4 + +Set 2, vector#928: + message=928 zero bits + hash=1D9C9AA4BD15F3B6DDDE9771259AA550F17CE01383DFC3E7 + +Set 2, vector#929: + message=929 zero bits + hash=61B0C2F60CAC0792E38DFF5BFB7F92D6A10C07BB9895DA51 + +Set 2, vector#930: + message=930 zero bits + hash=5D098CB9A3A7CDF25EE70D2F183091CA341BE5456E4986C7 + +Set 2, vector#931: + message=931 zero bits + hash=7D5C0748B9AC9B75FB51E882FE5390FC65B600BB8D91A35A + +Set 2, vector#932: + message=932 zero bits + hash=72E3E3B8199146E1EB60F702ACA6DA0D02ADF40C8C049496 + +Set 2, vector#933: + message=933 zero bits + hash=DF240A10A2F1FEF02FDAE685A3973500389D69F01CE513E4 + +Set 2, vector#934: + message=934 zero bits + hash=DCDD2CF23AC7AA3D2519EE44637C6DB443B694A033E5D9AD + +Set 2, vector#935: + message=935 zero bits + hash=E591A28130ABD26D11BD2BA1CA5E6E39CA3D28D63DF4B7E5 + +Set 2, vector#936: + message=936 zero bits + hash=D70BCAA1810D6213A77935D751F52C8743C809C37DCB02CE + +Set 2, vector#937: + message=937 zero bits + hash=E67C0050D6C3DEBBFA39340A050A9D027E7877692E62A984 + +Set 2, vector#938: + message=938 zero bits + hash=E2414AE32219B21C68743B6F1AFEE3E1404A3FAFA98A7FBB + +Set 2, vector#939: + message=939 zero bits + hash=B1DD7FE39ED11FD16C8F151B6A4228D54417B9B9BAB88C74 + +Set 2, vector#940: + message=940 zero bits + hash=617EA03C0238DBAE762058ABF591773FADB4123A446EA41D + +Set 2, vector#941: + message=941 zero bits + hash=C46F5E9D3DE419171E31BBE6CF841401F5075785C8B9E4B1 + +Set 2, vector#942: + message=942 zero bits + hash=D34EB71021AC4EF1D15E8E0B7A707EC8A1BE9BB86FA4F80D + +Set 2, vector#943: + message=943 zero bits + hash=A905880A72B09BFFE2A8F5913A8387D198488B4DD839EE61 + +Set 2, vector#944: + message=944 zero bits + hash=9759AE86B5CC71DB9406A2ABDD0537940D717E2953E4573F + +Set 2, vector#945: + message=945 zero bits + hash=BB15FEB841808032E9DD625A2E9134947BE7DBAD011877FB + +Set 2, vector#946: + message=946 zero bits + hash=766F7212528F0513A95B91687770FD435604AF23C707DCE4 + +Set 2, vector#947: + message=947 zero bits + hash=3D73370B4B8C4718910BEEAF025582D7CC5CE951CE5398CF + +Set 2, vector#948: + message=948 zero bits + hash=536F558449ACB5007A8634E303B93568E2FDF684FD828A3C + +Set 2, vector#949: + message=949 zero bits + hash=FF0BCAB96FD7666790B8CF26BF0D69486ECF67BEFDDF8B42 + +Set 2, vector#950: + message=950 zero bits + hash=83F59F7EB2AD0EAFE24DBF6DB09B1D81DDB7805263635B46 + +Set 2, vector#951: + message=951 zero bits + hash=157602AB22286DB308C8543C122BD5B6A3F6367DAB09F5CE + +Set 2, vector#952: + message=952 zero bits + hash=A6452EF736D5CFF79BC3C3DBAA7FC7B4B992AE7DBD87650B + +Set 2, vector#953: + message=953 zero bits + hash=A9D7DA3BA333C2FD8EE18589DB2A984294C0504787A57FFE + +Set 2, vector#954: + message=954 zero bits + hash=3E3377C9B4AB0A7A64DF073874B9E322B2BD3536C741F5E8 + +Set 2, vector#955: + message=955 zero bits + hash=73A0C487172CD3B1C9AFBA9D587F928B0A9A379ED64DFBDA + +Set 2, vector#956: + message=956 zero bits + hash=45C3EE530D205E4D46D5D35EA1D32D9385217C5DC30B9E18 + +Set 2, vector#957: + message=957 zero bits + hash=04929AFFFEFD318622A0AE1E7300E80103AAC778DE03FCA3 + +Set 2, vector#958: + message=958 zero bits + hash=02A01344BC4CAA53269780F894B79C37C59C3998B1B73602 + +Set 2, vector#959: + message=959 zero bits + hash=4905B6FCC9F01B59FAA17858B244864A7F0D872A225D9D6E + +Set 2, vector#960: + message=960 zero bits + hash=FB7177FFE0E718C91348A8302C57129596149F042FCC99A6 + +Set 2, vector#961: + message=961 zero bits + hash=F46D594A1FB8F5F5FC6B332705F891CFF41AB3251A40FA98 + +Set 2, vector#962: + message=962 zero bits + hash=7763A5AE2B3CE4592CCDF64BD51942F3BDD437E995A6ED78 + +Set 2, vector#963: + message=963 zero bits + hash=B3B8F20652D349F5C93F9579B9BDEAC300882D0A61BE4745 + +Set 2, vector#964: + message=964 zero bits + hash=9BB79648CE27C21321FA6138EE6CAA81AB467AE6F04B166F + +Set 2, vector#965: + message=965 zero bits + hash=F7AAEE1F059E711CAB253859584750A4B418F70F3EA58C89 + +Set 2, vector#966: + message=966 zero bits + hash=D060B1380EFD22C62F4CFCCB0EA9F38107082268C9D2F1DC + +Set 2, vector#967: + message=967 zero bits + hash=D64C3D7391A05DEFECD33AB76CD8C00FC0322A514F43BCB9 + +Set 2, vector#968: + message=968 zero bits + hash=A6FABD413D9FAF90AC0A8D97F82B1D28761D9B3A7A3A2E2C + +Set 2, vector#969: + message=969 zero bits + hash=0743EA171C8F7E2E5652F8F3CB5FA6160B6C10A7B2163A09 + +Set 2, vector#970: + message=970 zero bits + hash=F1BBF6AB567E8A418A0640011065C108355B73D9E8A13E06 + +Set 2, vector#971: + message=971 zero bits + hash=0C011CC846B6C1D17748370C507A6087879724C77E6F895C + +Set 2, vector#972: + message=972 zero bits + hash=C73288676D7386884F209E397AE2F0D644F0B58F5AEC396A + +Set 2, vector#973: + message=973 zero bits + hash=B569BDB58E1278E882EA79ED03BB25BDBB6F30EC198FD075 + +Set 2, vector#974: + message=974 zero bits + hash=1AB097C34955500E0F14A403CB274DACCBADDC5B282ED20E + +Set 2, vector#975: + message=975 zero bits + hash=77343AAF547903DFA492E433DFC3813CABE3B9675CE3F963 + +Set 2, vector#976: + message=976 zero bits + hash=93E56AE559EC7BF41251B6C84700465BF78E0757576679B3 + +Set 2, vector#977: + message=977 zero bits + hash=9E7CA24A44F2A04321346AE94D53C63928D7BC899BED8A82 + +Set 2, vector#978: + message=978 zero bits + hash=04FD1D8D78453F5B76130BC6EDC32A809AC2D8687CBCBD25 + +Set 2, vector#979: + message=979 zero bits + hash=8D827EBCEE3DC3AC0E4FCFBE7FB983FC0E528C182AA65A7D + +Set 2, vector#980: + message=980 zero bits + hash=85C63DD5B13A570D3CACEE930FDECB732C1B871F046AA2C8 + +Set 2, vector#981: + message=981 zero bits + hash=1F719EEC174264D8F7818E7C2EE8721941C9CD2872D5A15A + +Set 2, vector#982: + message=982 zero bits + hash=320057361FB2290EB402EFAF0E166E92B189E224DE370043 + +Set 2, vector#983: + message=983 zero bits + hash=7EE50C9A0A119614BAADFBB2FF1F3716717682D83A1A9635 + +Set 2, vector#984: + message=984 zero bits + hash=24F342F67741BFD5CCA5E9C5C0D902CB6F93DF12203E891A + +Set 2, vector#985: + message=985 zero bits + hash=3EE0B097849C633AA6BF497BB2A04E1EAB97E21756C9B491 + +Set 2, vector#986: + message=986 zero bits + hash=4DFB2BF0FFEA3B99AC3E8B18F2723D4A9CF38E7257F05064 + +Set 2, vector#987: + message=987 zero bits + hash=557844D3C791C5E13CEE914C1159C0227665DEC5A7585C52 + +Set 2, vector#988: + message=988 zero bits + hash=E12CAA734CA519989A767086A1FCCA376C2A9B71740A7637 + +Set 2, vector#989: + message=989 zero bits + hash=CC58C605B4BA16951B3DF7249561E221C468D3E3BDCEAAA8 + +Set 2, vector#990: + message=990 zero bits + hash=B2AF478115BC6A4379E124EC1A8567B7C3F391BC0FE1EAF3 + +Set 2, vector#991: + message=991 zero bits + hash=11A3F472D1FAB6634316D279144BB75B1B7065AC6E68CAE6 + +Set 2, vector#992: + message=992 zero bits + hash=BE7803AE8A8C84B7567352C2E3A78BE424784406D33F6930 + +Set 2, vector#993: + message=993 zero bits + hash=A0186815401B6806A9195F1FD2256543510839753B4D1D8E + +Set 2, vector#994: + message=994 zero bits + hash=11C6281ADE09440B1E4D8E6A816BEC60072CB5E4BF5590CA + +Set 2, vector#995: + message=995 zero bits + hash=5A529ACF90CF7298EE1955025C19BBB58A85875C849290D0 + +Set 2, vector#996: + message=996 zero bits + hash=0C86082F2F99EFB85BA059EB713A74899D427F8C3C3A3587 + +Set 2, vector#997: + message=997 zero bits + hash=2C1E11FF5A6DF6B418301CA51E87241F08D5C6ED2AD4D619 + +Set 2, vector#998: + message=998 zero bits + hash=A65C07D1025AEDA56C53DD8D2A216C2725762242B882BC25 + +Set 2, vector#999: + message=999 zero bits + hash=F3F7DBCEFCC20915945CE89F9912752663637B559044DC80 + +Set 2, vector#1000: + message=1000 zero bits + hash=43A59ECAB48D3784CD83B0887E92D208A0E7CEC6DA3A7146 + +Set 2, vector#1001: + message=1001 zero bits + hash=942D19B88EF907364D60442901F7A0A221B989345E42A176 + +Set 2, vector#1002: + message=1002 zero bits + hash=717ABB96B6B7DFF066B33468B25FF28702C59E13149DC31E + +Set 2, vector#1003: + message=1003 zero bits + hash=1259C6B02D3705740F4ACFF45E6533D0B10722F060B09746 + +Set 2, vector#1004: + message=1004 zero bits + hash=6C5250DF2B3D049491B2D118CD85C1D20AD75E21E4A33E75 + +Set 2, vector#1005: + message=1005 zero bits + hash=45F92071F99A476979F8FBE6BB46C105B0B1C36CB539D0ED + +Set 2, vector#1006: + message=1006 zero bits + hash=B01EFEF2DE4884484C5154C195E4E1B76AC7B1846D3E1628 + +Set 2, vector#1007: + message=1007 zero bits + hash=63F3C21D32DC45978E2895DE7010358341E89562CD0FA5D3 + +Set 2, vector#1008: + message=1008 zero bits + hash=7D16DC5E00379CA0F13FA261AD5FDB56449ADF9DAD3810E1 + +Set 2, vector#1009: + message=1009 zero bits + hash=BB656BB3435E8CD66C9B8C751586579BDC951D0188A5753E + +Set 2, vector#1010: + message=1010 zero bits + hash=40EB29886A607B99E6D5D8D828976B7F752DCF89EE5823F2 + +Set 2, vector#1011: + message=1011 zero bits + hash=3467CD5CE610146F8D39D876145AD481C95954279A1B745C + +Set 2, vector#1012: + message=1012 zero bits + hash=337CD30C26D92A6560D82CC552C41A5780AAEAE426835ACC + +Set 2, vector#1013: + message=1013 zero bits + hash=EBF4D50EABB98924EE598D739079924B5E76281115C30C50 + +Set 2, vector#1014: + message=1014 zero bits + hash=05D6183AF648A3508F70D883F89F71EFE7157F7D8BFD95D3 + +Set 2, vector#1015: + message=1015 zero bits + hash=440894BFAE62ED76926DCE0EC00A81EAEC3BD2B2F8740B7D + +Set 2, vector#1016: + message=1016 zero bits + hash=00A569CCADB17662483CA36230BCC6956BA5C1D5595C044A + +Set 2, vector#1017: + message=1017 zero bits + hash=45F7C003B6C3F28E3E27D6C3C704D149BCE7E10103730D99 + +Set 2, vector#1018: + message=1018 zero bits + hash=017E404BB5D8D41733E5439C543E8F1BCE608D3CD2649BC0 + +Set 2, vector#1019: + message=1019 zero bits + hash=7A5BC59EBF4755AEC4C755663C6381B949C40B856FBE28A4 + +Set 2, vector#1020: + message=1020 zero bits + hash=67187125CA3CD630863CD90DF96C5A863B8E37D3CC75165F + +Set 2, vector#1021: + message=1021 zero bits + hash=F350816A79C72F1D8477CC8FE60D81C139606EF73D32DF4E + +Set 2, vector#1022: + message=1022 zero bits + hash=469D6127ED99F0C606944971EA2E953DAABD98A4130D2988 + +Set 2, vector#1023: + message=1023 zero bits + hash=5E5319090C0C136D1838A01DCEECFF79896A942C1921C983 + + +Test vectors -- set 3 +===================== +Message digests of all 512-bit strings S containing a single 1-bit: + +Set 3, vector# 0: + message=512-bit string: 0*00,80,63*00 + hash=B99F2BEFF1E64861ECB3D91B04C9BA4BE6FC0FE7CE9653F3 + +Set 3, vector# 1: + message=512-bit string: 0*00,40,63*00 + hash=FBDD470EE15111676B477532D293019EB182CE9EF17C0B59 + +Set 3, vector# 2: + message=512-bit string: 0*00,20,63*00 + hash=D68BC840B64746A212810784CAB2BBDFCC49FDC743AFF5D4 + +Set 3, vector# 3: + message=512-bit string: 0*00,10,63*00 + hash=D6B280F151C286E2B8A78B3C80F181E192BEEC0A339F0453 + +Set 3, vector# 4: + message=512-bit string: 0*00,08,63*00 + hash=02FDBD79A641FDB807DD80699019BC97DA69D692104FBFCB + +Set 3, vector# 5: + message=512-bit string: 0*00,04,63*00 + hash=E30F39FBB7BB8C191E2CD9A970EC806EA64825E4CCE782D7 + +Set 3, vector# 6: + message=512-bit string: 0*00,02,63*00 + hash=0521BC64D5C188320CB9AE9D2A89BE291352F77C3E44772B + +Set 3, vector# 7: + message=512-bit string: 0*00,01,63*00 + hash=60224F0B05145D00FB3C09E78522FE17FB7C64AC90AF4BE0 + +Set 3, vector# 8: + message=512-bit string: 1*00,80,62*00 + hash=3104BE53E8A19ED90BB03DA1FC5FBD052EE7D80B4AB31AF2 + +Set 3, vector# 9: + message=512-bit string: 1*00,40,62*00 + hash=ECE34E9D1BBA44EBAAF18254812DA74E1B250D874049471F + +Set 3, vector# 10: + message=512-bit string: 1*00,20,62*00 + hash=7FBEF692D8F3DB59912960E1C4F255D65CFA93E64CDA00B3 + +Set 3, vector# 11: + message=512-bit string: 1*00,10,62*00 + hash=180C2B906440036CB48ED7DBD670CDD06054734CA9E3E531 + +Set 3, vector# 12: + message=512-bit string: 1*00,08,62*00 + hash=EC1C85F1C4361CCC979FA94565CE47BA766B26C03E0155ED + +Set 3, vector# 13: + message=512-bit string: 1*00,04,62*00 + hash=0CB103FE2F16046BCF473C0EF5F30510094B327A811303AC + +Set 3, vector# 14: + message=512-bit string: 1*00,02,62*00 + hash=35E499F9FCCE1B0CFE442FE493333763C8E5F956A255DDBE + +Set 3, vector# 15: + message=512-bit string: 1*00,01,62*00 + hash=E8CFB0B7651DCF73891553FE1AD3DC0F1BF5CA89E2243771 + +Set 3, vector# 16: + message=512-bit string: 2*00,80,61*00 + hash=9F375EFC406EDB4DC7008C6ADF57CE7BC6072BD39593651A + +Set 3, vector# 17: + message=512-bit string: 2*00,40,61*00 + hash=C40960EE520A3F6E38938C4D774695FAB9AA99ED98724686 + +Set 3, vector# 18: + message=512-bit string: 2*00,20,61*00 + hash=C925142A228B90DC4EEE8D740480095B72EEF71717AF230D + +Set 3, vector# 19: + message=512-bit string: 2*00,10,61*00 + hash=49F67D2EE9E5E07754EB3FB587A5DFC9A5A5F1AF952ABB90 + +Set 3, vector# 20: + message=512-bit string: 2*00,08,61*00 + hash=8EA4A53FB597B8612B751B25B4D67A3211BD9B55810830FB + +Set 3, vector# 21: + message=512-bit string: 2*00,04,61*00 + hash=7F8A9779678C20D7B26126CE54CF40D586D639038E0D898A + +Set 3, vector# 22: + message=512-bit string: 2*00,02,61*00 + hash=45B2D2247DF2BE8762F7C2BFB1D282DB99686B8C61F12DC2 + +Set 3, vector# 23: + message=512-bit string: 2*00,01,61*00 + hash=5AF3F43A65A123F25318B108322F1422FBDD4E2088B3FCC5 + +Set 3, vector# 24: + message=512-bit string: 3*00,80,60*00 + hash=255BA44E43BB186AC95A8BA873F27C17D4209A7CDA0743E8 + +Set 3, vector# 25: + message=512-bit string: 3*00,40,60*00 + hash=6CC1C5FE50A6A3E1A8C9151E529627B7825E797CA2996763 + +Set 3, vector# 26: + message=512-bit string: 3*00,20,60*00 + hash=4C8E2574514F1908500775D706E66CB5E098A07763CB29A8 + +Set 3, vector# 27: + message=512-bit string: 3*00,10,60*00 + hash=80E15B5D7DD082786B73BFA7C11ABE846CC08992D82082EF + +Set 3, vector# 28: + message=512-bit string: 3*00,08,60*00 + hash=9AAEDC20A2B5C9B3AC1FEAB011E0BC63C3F14A77716745B4 + +Set 3, vector# 29: + message=512-bit string: 3*00,04,60*00 + hash=20FDDFC28496F4B7C474D1DC0D2556B71A0BBE0008FBCA74 + +Set 3, vector# 30: + message=512-bit string: 3*00,02,60*00 + hash=6C5437A6A7ACD3882300183FBE7B474CB7C0E45DF4BF126E + +Set 3, vector# 31: + message=512-bit string: 3*00,01,60*00 + hash=3220E4DE2B99FD792057CA379EC8E0FB9277B2B0AFCAF7E1 + +Set 3, vector# 32: + message=512-bit string: 4*00,80,59*00 + hash=5605262344AED0F46F6AA94AAE288A936B3783D7B0C96EBB + +Set 3, vector# 33: + message=512-bit string: 4*00,40,59*00 + hash=79FE05ED00EA9FBE5C5A411B7BE9D0AB7E95FCAC4944FB5A + +Set 3, vector# 34: + message=512-bit string: 4*00,20,59*00 + hash=5632B77A86B06F60FB38F6F8D7B8ACB076610CDB17C45F3B + +Set 3, vector# 35: + message=512-bit string: 4*00,10,59*00 + hash=6F1C90B7CE7D352A1EAF908EAAEB69DE70CFEA924FA1F322 + +Set 3, vector# 36: + message=512-bit string: 4*00,08,59*00 + hash=B0582D1882AC0B5C534293ABB751072EACFCBCCD7760B739 + +Set 3, vector# 37: + message=512-bit string: 4*00,04,59*00 + hash=D56CC1F5522E00EF7F25DA7C524CFBEF639E04ED232FDA74 + +Set 3, vector# 38: + message=512-bit string: 4*00,02,59*00 + hash=FDD3E72BD41951FF6CA729207F9EE320F277C240C5ABA6CE + +Set 3, vector# 39: + message=512-bit string: 4*00,01,59*00 + hash=25C341EFBF8E0197DD7AA0D098BE9C262EA24A5ABF1956DC + +Set 3, vector# 40: + message=512-bit string: 5*00,80,58*00 + hash=3D8E11219C1F4A655DE818DD5BAE94724292D1FC1F2C0451 + +Set 3, vector# 41: + message=512-bit string: 5*00,40,58*00 + hash=78D0C2AEAAB13E6957111303BCE092987F38B125654AEB06 + +Set 3, vector# 42: + message=512-bit string: 5*00,20,58*00 + hash=76CE1A38D5408FCF5C60F231F8624D22EBE4F3C2A77833CA + +Set 3, vector# 43: + message=512-bit string: 5*00,10,58*00 + hash=A1478F92ACD8AFBF1383F566E8074249C576C6C01573C816 + +Set 3, vector# 44: + message=512-bit string: 5*00,08,58*00 + hash=EEF978C6730A5A51E0C67CA0CD591718F48E586924DACAC3 + +Set 3, vector# 45: + message=512-bit string: 5*00,04,58*00 + hash=D244E12581769DF1260AD3B9BADFEAACAEC10F08D0BC20B8 + +Set 3, vector# 46: + message=512-bit string: 5*00,02,58*00 + hash=6C88A229FF9769C257AE208427684E2BD2F2616FB11DC61E + +Set 3, vector# 47: + message=512-bit string: 5*00,01,58*00 + hash=F9AA7D877F5B192A751D6956225FBB166E70BB5373EA03B5 + +Set 3, vector# 48: + message=512-bit string: 6*00,80,57*00 + hash=8E5FC1110E41E417B771F4860BD7180A8771EC8BE3F51371 + +Set 3, vector# 49: + message=512-bit string: 6*00,40,57*00 + hash=16A04075744A70693EDC2823E6D3F53F8BD7DA82F61C988A + +Set 3, vector# 50: + message=512-bit string: 6*00,20,57*00 + hash=DAA5DCE2246AA0B16DFCB5A6DE1148A4667CF130CB0FE57A + +Set 3, vector# 51: + message=512-bit string: 6*00,10,57*00 + hash=7935C3EAC77062032E4DA41CFE266DB7B1CEAD6A92F36531 + +Set 3, vector# 52: + message=512-bit string: 6*00,08,57*00 + hash=12FAFE2DD9FE0F928585DBFFDF2FC940329F4CA2C428FFA2 + +Set 3, vector# 53: + message=512-bit string: 6*00,04,57*00 + hash=B5AF46B22173E04EC7C73D201D230E76AFF7E25E7C64C9A1 + +Set 3, vector# 54: + message=512-bit string: 6*00,02,57*00 + hash=04A39346609CC870A34BFE4BC381391E5096EECC0420CBE0 + +Set 3, vector# 55: + message=512-bit string: 6*00,01,57*00 + hash=8E30346B3CF6A33A5DF960349E79E318A559177A10132AE5 + +Set 3, vector# 56: + message=512-bit string: 7*00,80,56*00 + hash=E010FE9A2A139AF552D7A22D5D04D59ABE9F26099565B139 + +Set 3, vector# 57: + message=512-bit string: 7*00,40,56*00 + hash=7E3A17F0489C5D1CF249BDFD6D839D17797E5F91655061DF + +Set 3, vector# 58: + message=512-bit string: 7*00,20,56*00 + hash=DB0EDCB6F326FFC5EC6C23A9B23630110BCF3EF1623090C7 + +Set 3, vector# 59: + message=512-bit string: 7*00,10,56*00 + hash=0E878D8D2984F9A638DFF1A309EA4B436D24FA40B3BC5F4D + +Set 3, vector# 60: + message=512-bit string: 7*00,08,56*00 + hash=AE09F204A5E6EEA22BADD0042D00D48E60643343C951C79D + +Set 3, vector# 61: + message=512-bit string: 7*00,04,56*00 + hash=5411134E8112EBD21A89CA726D6C3293BAF1522031BFED57 + +Set 3, vector# 62: + message=512-bit string: 7*00,02,56*00 + hash=1CC1D5B8489F213F6A0519811867CA70AAB68B93768B2EAB + +Set 3, vector# 63: + message=512-bit string: 7*00,01,56*00 + hash=A16D7299661CC6978AE949CF9F607E286913CA0615E12CEB + +Set 3, vector# 64: + message=512-bit string: 8*00,80,55*00 + hash=9A2A8EE8963BE88DF83D5761D490FFB0450E9C450542CB08 + +Set 3, vector# 65: + message=512-bit string: 8*00,40,55*00 + hash=FAC9C5FB38BF7CE0902DC3E447D3D4D6DD369DBE94A8AB67 + +Set 3, vector# 66: + message=512-bit string: 8*00,20,55*00 + hash=C430CAA3FD05B674624BB549B3A565C9F1A93D8E4AE429E0 + +Set 3, vector# 67: + message=512-bit string: 8*00,10,55*00 + hash=D03C16013ACB204439B0B84C5EC0507C07EAD360114BB6D7 + +Set 3, vector# 68: + message=512-bit string: 8*00,08,55*00 + hash=44F6F5EFA89F2302B9E4B6710EFA1BD79F2589575F57B7A0 + +Set 3, vector# 69: + message=512-bit string: 8*00,04,55*00 + hash=C392AF0E93D619A0FAAC3FC2EE960DE9464DF3F3B87728D6 + +Set 3, vector# 70: + message=512-bit string: 8*00,02,55*00 + hash=BF1C5CF1B59A39C9EFD3D46F9144E7E7CC75F53C83BE87AB + +Set 3, vector# 71: + message=512-bit string: 8*00,01,55*00 + hash=F4DEAFA84B6859F0B32D04DA3CF8DED931870EB8EBA086B6 + +Set 3, vector# 72: + message=512-bit string: 9*00,80,54*00 + hash=68B3511E9A930CC1E465DDADD3813E79E5235690E279A53A + +Set 3, vector# 73: + message=512-bit string: 9*00,40,54*00 + hash=D98B1C76BF4216804783DD2A082F5722AE7049717AC6BEE4 + +Set 3, vector# 74: + message=512-bit string: 9*00,20,54*00 + hash=8FE146611B75E5E6527F0E2516F09090FABE1AE0F51D9965 + +Set 3, vector# 75: + message=512-bit string: 9*00,10,54*00 + hash=B6F4518C9B5A082BA4951EEFEE8991D2605395D04FFD9784 + +Set 3, vector# 76: + message=512-bit string: 9*00,08,54*00 + hash=0C4C268E0243354A31C576B053FCECCD320D864892DD4452 + +Set 3, vector# 77: + message=512-bit string: 9*00,04,54*00 + hash=4FCBCA86DAAD5EE31427339F45DB698C56F4EF5977C62346 + +Set 3, vector# 78: + message=512-bit string: 9*00,02,54*00 + hash=D63400C91F46CEB1F73427A1DD61920E5D98250CD7B21D61 + +Set 3, vector# 79: + message=512-bit string: 9*00,01,54*00 + hash=2002BE33AA6783F40109E747E27231C652FC90B304F91218 + +Set 3, vector# 80: + message=512-bit string: 10*00,80,53*00 + hash=A8FEDBD8A393C41857EA09B457FDB42078049B3F269C1431 + +Set 3, vector# 81: + message=512-bit string: 10*00,40,53*00 + hash=D2C06B7D56774863AB6F3A9F8FFD79FB56FF130906B16596 + +Set 3, vector# 82: + message=512-bit string: 10*00,20,53*00 + hash=5D8339715D342E8DDCB7CF18F4878D2221BB05FC4B2563BD + +Set 3, vector# 83: + message=512-bit string: 10*00,10,53*00 + hash=06DEF00E4151BBFA011D87096B16C09A955B1059EBA03393 + +Set 3, vector# 84: + message=512-bit string: 10*00,08,53*00 + hash=36386BE0645E7577BFF63BAAC50532912EBB7026B120E472 + +Set 3, vector# 85: + message=512-bit string: 10*00,04,53*00 + hash=8E4CAC8FE8C09463A5726B0FD3335A09E8971B498CCFC14E + +Set 3, vector# 86: + message=512-bit string: 10*00,02,53*00 + hash=45EA2AE4AD4B1E0C6958FABC69939E1A19300E28946638E8 + +Set 3, vector# 87: + message=512-bit string: 10*00,01,53*00 + hash=7C97246A7834ECF7074DCAD08A8B4BF3E8A68157889B97E4 + +Set 3, vector# 88: + message=512-bit string: 11*00,80,52*00 + hash=0F040C8CB0C777EE04086DDEAC53751D037FC41A62DF3D64 + +Set 3, vector# 89: + message=512-bit string: 11*00,40,52*00 + hash=011A9D0417A070DA0D425E835F03C68D0BD8762A7174C0A6 + +Set 3, vector# 90: + message=512-bit string: 11*00,20,52*00 + hash=76B90E3049F98281369B0ACD1D2193EF2F63A25F75D9FEA1 + +Set 3, vector# 91: + message=512-bit string: 11*00,10,52*00 + hash=733DBC18BB0821CD1B33210BD9018F2EAF405E0A281328B4 + +Set 3, vector# 92: + message=512-bit string: 11*00,08,52*00 + hash=4C3B42FEA3DA2B23AE3C723B22522AECC84BB1D5CD2F9E51 + +Set 3, vector# 93: + message=512-bit string: 11*00,04,52*00 + hash=77396616E87FDEEBDB6276B30422B04C2098F85F0085371D + +Set 3, vector# 94: + message=512-bit string: 11*00,02,52*00 + hash=6BD882666B2089F5A3904F91E26B34263BEF463456486ECA + +Set 3, vector# 95: + message=512-bit string: 11*00,01,52*00 + hash=1AA8BC49C40EEADA030EE802C336D83D75C3EEECDF365AB2 + +Set 3, vector# 96: + message=512-bit string: 12*00,80,51*00 + hash=6E9615A0291AEB33D37FFF3BDDAF628178009820457F0737 + +Set 3, vector# 97: + message=512-bit string: 12*00,40,51*00 + hash=F78CB6642756E3253A46FC55E5C852B5D209CB886F1953D4 + +Set 3, vector# 98: + message=512-bit string: 12*00,20,51*00 + hash=3D900B55C9CD9E821512415B734B06A28B8EFB0488F9EB4E + +Set 3, vector# 99: + message=512-bit string: 12*00,10,51*00 + hash=1D534936BE6E2831E83661E0568B170EF52712899E2F8A8C + +Set 3, vector#100: + message=512-bit string: 12*00,08,51*00 + hash=68D08DCA280F71F6E33FE81F56BF5D98BB498B720F8294F4 + +Set 3, vector#101: + message=512-bit string: 12*00,04,51*00 + hash=D4D1339C8797918AEB4000CE0B75EB741EEA852B7E5FEF35 + +Set 3, vector#102: + message=512-bit string: 12*00,02,51*00 + hash=F6204099D4C1B7F82BF0A1364A6322C3578A46F354A68622 + +Set 3, vector#103: + message=512-bit string: 12*00,01,51*00 + hash=FC94F4DFB37B4674843E0CD9DAFDE149D89667915DEFAEFA + +Set 3, vector#104: + message=512-bit string: 13*00,80,50*00 + hash=F64C25ED176B388E022A3AA4622975F1CEC7A9A359D1D28A + +Set 3, vector#105: + message=512-bit string: 13*00,40,50*00 + hash=CE3230D5A7B57E82F92D8A36485B0EF70B3A8430391907F8 + +Set 3, vector#106: + message=512-bit string: 13*00,20,50*00 + hash=D9AC7B94226A60FC7D99CD796FD5B6EA36AE798047E1B53D + +Set 3, vector#107: + message=512-bit string: 13*00,10,50*00 + hash=8A9F12D8D9DF81E43E9DC038FBA927A3A0A0D6FA43749D2D + +Set 3, vector#108: + message=512-bit string: 13*00,08,50*00 + hash=CCAE282196A07B02E896FDDBC71616298BBBC436BED3D424 + +Set 3, vector#109: + message=512-bit string: 13*00,04,50*00 + hash=09503A7A95B31206D16FC3A3A6730CB379F413C255B0916A + +Set 3, vector#110: + message=512-bit string: 13*00,02,50*00 + hash=0D799B12AF89A92E0E91237F37236BA484B5192B468F92B4 + +Set 3, vector#111: + message=512-bit string: 13*00,01,50*00 + hash=04A3597758A82EE3EAA34F5B0FB1198A1177B3B3B8DD583C + +Set 3, vector#112: + message=512-bit string: 14*00,80,49*00 + hash=BAC0B8BE5A41BB8186CABAD7A32F17559DB8579D2A32ED35 + +Set 3, vector#113: + message=512-bit string: 14*00,40,49*00 + hash=96B5AD3931A54DF4C0754FFD17E2ED27EEDBA480D7DEC700 + +Set 3, vector#114: + message=512-bit string: 14*00,20,49*00 + hash=4A3E600FE13F444B31E03CFA0863F9E316F83F68F16D509D + +Set 3, vector#115: + message=512-bit string: 14*00,10,49*00 + hash=B5DA026AE3BFBFAC6D2AB00A16ECFBA40130E1817E26E6FD + +Set 3, vector#116: + message=512-bit string: 14*00,08,49*00 + hash=635799A28E0E31EF6DA157BE71327548E1EBBE93D39A40CE + +Set 3, vector#117: + message=512-bit string: 14*00,04,49*00 + hash=00A7C94AC7D6DA73AF3537816D7535F6501C81E9D0B70C30 + +Set 3, vector#118: + message=512-bit string: 14*00,02,49*00 + hash=CEA02CEB43D209ABA6217234278931ECB509813A516C8770 + +Set 3, vector#119: + message=512-bit string: 14*00,01,49*00 + hash=460F8608C1CE8A7ED701C8D46D800E5097DD421321A595BF + +Set 3, vector#120: + message=512-bit string: 15*00,80,48*00 + hash=595B7A837EA74AE2A9C2A4DD9915C684E4003A78C908EB34 + +Set 3, vector#121: + message=512-bit string: 15*00,40,48*00 + hash=40A34377B74D9C7404E69898DA030F47C7B4F5125379799C + +Set 3, vector#122: + message=512-bit string: 15*00,20,48*00 + hash=011A1626ACDE5490D40D6D3B212E4296DBCFAA310C0D0A7D + +Set 3, vector#123: + message=512-bit string: 15*00,10,48*00 + hash=0C38A676E739B11BF2B5F305DFC38C1194B67D5BD9ABDD3B + +Set 3, vector#124: + message=512-bit string: 15*00,08,48*00 + hash=B2BDB49CBB6A27D90DC43CAEF626531E3794B02A4B557363 + +Set 3, vector#125: + message=512-bit string: 15*00,04,48*00 + hash=925F73F9BF011425B3C855EB93FF2B3702994957C90A6E71 + +Set 3, vector#126: + message=512-bit string: 15*00,02,48*00 + hash=C5438E4F6F20FA52579EA70DBE976E8ED0CD0CA79F0FF667 + +Set 3, vector#127: + message=512-bit string: 15*00,01,48*00 + hash=9C19CE6E144C81EDBEFA42762CCE7687D82D90C80E6E4DD7 + +Set 3, vector#128: + message=512-bit string: 16*00,80,47*00 + hash=F6F514983734179B56A2DB5810D2FEF9FBAAE792DF757EE6 + +Set 3, vector#129: + message=512-bit string: 16*00,40,47*00 + hash=47EA4D78437E145E56490DD5C47788BEC899AB249A782AF1 + +Set 3, vector#130: + message=512-bit string: 16*00,20,47*00 + hash=751FCB36A8B567673E9571B4F359CB7452913DE68458233B + +Set 3, vector#131: + message=512-bit string: 16*00,10,47*00 + hash=6B86FAA0426879F9C1A6F4A9F26FF19DADCD0BA2C34273F2 + +Set 3, vector#132: + message=512-bit string: 16*00,08,47*00 + hash=8ABD32BED2814C6428812B67CB7228BF02AC80EC80C5771C + +Set 3, vector#133: + message=512-bit string: 16*00,04,47*00 + hash=026EE4B31888E474E20F1627B30475FFEE90BAFA2E214CE2 + +Set 3, vector#134: + message=512-bit string: 16*00,02,47*00 + hash=6EA00649517124D6598C2CBB109B8F8AC445771A9550263D + +Set 3, vector#135: + message=512-bit string: 16*00,01,47*00 + hash=9029BD1306510D7BFCEF39B7E3E6F3A62993A810141919A4 + +Set 3, vector#136: + message=512-bit string: 17*00,80,46*00 + hash=802BE35C1D0356AA8D7E7830C1426AA9789CF9B1B75C7145 + +Set 3, vector#137: + message=512-bit string: 17*00,40,46*00 + hash=78D1FE031819E727172B1FB5A0EC87AC33C494C1E37C222E + +Set 3, vector#138: + message=512-bit string: 17*00,20,46*00 + hash=E87A76683F7B6D8CA2B47C8C41F346764053D8841FBE610E + +Set 3, vector#139: + message=512-bit string: 17*00,10,46*00 + hash=E3E18819D97CD24E6C82AF5212876375134D9401E1CFB25B + +Set 3, vector#140: + message=512-bit string: 17*00,08,46*00 + hash=528D81D4D77B3C9360D1CCB3D8D906FAD4BAEEB8C417AF8E + +Set 3, vector#141: + message=512-bit string: 17*00,04,46*00 + hash=940509DDE91065297F51C95D6D61196BCADDFFBFE43A0490 + +Set 3, vector#142: + message=512-bit string: 17*00,02,46*00 + hash=1F745AD4161EE006A4260D7249E0B68B0453B01819EB2A14 + +Set 3, vector#143: + message=512-bit string: 17*00,01,46*00 + hash=B1AA443FAA0B47E51A307ECAC7FAF07CA8732E715513C738 + +Set 3, vector#144: + message=512-bit string: 18*00,80,45*00 + hash=CB30A43A2DE29002ECE22BD0CA7FA5C40E0F1EE3C9784249 + +Set 3, vector#145: + message=512-bit string: 18*00,40,45*00 + hash=A5B6D8400303E5118489CE082241808027945C143D1200AC + +Set 3, vector#146: + message=512-bit string: 18*00,20,45*00 + hash=FFB82281B7B2CDFF2E83440CFEC036D03C26BD5133AA56C8 + +Set 3, vector#147: + message=512-bit string: 18*00,10,45*00 + hash=08F21816D77A3D5F7DFFFC5477C4EB78AF660D7C32B1B6F0 + +Set 3, vector#148: + message=512-bit string: 18*00,08,45*00 + hash=286FC4EA0BA3EE25CA28CD635DA1077BA00B7BBE1D319C9C + +Set 3, vector#149: + message=512-bit string: 18*00,04,45*00 + hash=ABD221DECE666C1E0ADE89ED127001B1AE8B37A3249BC237 + +Set 3, vector#150: + message=512-bit string: 18*00,02,45*00 + hash=EFD037EAD7168C5B48E18DBB0BFE94E7A7337ED9F9DC0B60 + +Set 3, vector#151: + message=512-bit string: 18*00,01,45*00 + hash=17A915BB90D878000A07BBF2F7C29605541CCBB2BA33BA9B + +Set 3, vector#152: + message=512-bit string: 19*00,80,44*00 + hash=EDBA011909174DACC7276FB748DA3D72037688E09B471CDB + +Set 3, vector#153: + message=512-bit string: 19*00,40,44*00 + hash=18646AB2DFAC64E3D1B8298F9DA48F8ACD3EC8E9B6C091D2 + +Set 3, vector#154: + message=512-bit string: 19*00,20,44*00 + hash=5BB55C940C48C5F173356ED2F76F135BB33C49C6FF401CE8 + +Set 3, vector#155: + message=512-bit string: 19*00,10,44*00 + hash=444CCFDECBBCAAC55FD538C84FECE4AD05E1F86CA2183046 + +Set 3, vector#156: + message=512-bit string: 19*00,08,44*00 + hash=0DD2986EBE58B62051C5F8558B33B2150E2162273A21D2D6 + +Set 3, vector#157: + message=512-bit string: 19*00,04,44*00 + hash=BBD0BE785D950FEE7272A6A42E20EEF9FCC96DA0862A9D4F + +Set 3, vector#158: + message=512-bit string: 19*00,02,44*00 + hash=C6EE3736BED22F09A3082957D5D2D9939E926DE56B23E540 + +Set 3, vector#159: + message=512-bit string: 19*00,01,44*00 + hash=F272AA5CC30126CA15ACF94904EA44A28068BD3B3ED74BDB + +Set 3, vector#160: + message=512-bit string: 20*00,80,43*00 + hash=24713F450026D6D9717475558F33A84CEC5B8EC74367A1F4 + +Set 3, vector#161: + message=512-bit string: 20*00,40,43*00 + hash=021A9ECFC35A18BC91568F76A06EA7B6F068B1B45E725F2C + +Set 3, vector#162: + message=512-bit string: 20*00,20,43*00 + hash=54027E9B61191C3ADE350615D809EC6A4BF7FE926946F93B + +Set 3, vector#163: + message=512-bit string: 20*00,10,43*00 + hash=27C362B26734609E760ED30E492273A2EC0786CECE1B62F7 + +Set 3, vector#164: + message=512-bit string: 20*00,08,43*00 + hash=C56A7C83A9F780DBFC564564D60B110894B3462BF202B31B + +Set 3, vector#165: + message=512-bit string: 20*00,04,43*00 + hash=E46DAE97BF1D1433B91E7C4B30A3D11189BD1959F363C8AA + +Set 3, vector#166: + message=512-bit string: 20*00,02,43*00 + hash=DFFFD3EE84CE33EDBD6CCBDF9FDBC4C6CD9F6C3663AB3124 + +Set 3, vector#167: + message=512-bit string: 20*00,01,43*00 + hash=CA9D313C0A9D62198C2528B856627BC9C70DD1C6523AA09D + +Set 3, vector#168: + message=512-bit string: 21*00,80,42*00 + hash=DAB676CBA9ABC9799E4416E703CD4C89348F3513D93BCE58 + +Set 3, vector#169: + message=512-bit string: 21*00,40,42*00 + hash=383C379EE484CB248AF0008F339F2B76C25DB122ABE46C2B + +Set 3, vector#170: + message=512-bit string: 21*00,20,42*00 + hash=466C5466009BFF5B4D9639CC2DDFFBEC31663189A11A3F06 + +Set 3, vector#171: + message=512-bit string: 21*00,10,42*00 + hash=5C2457FB54624D291D0223FDCA7CE3EAFB85B6D492408A9D + +Set 3, vector#172: + message=512-bit string: 21*00,08,42*00 + hash=FE593DC31045C782EC6B52216FC64B35FD33EE3904BA9966 + +Set 3, vector#173: + message=512-bit string: 21*00,04,42*00 + hash=D7174534437E6168C2EF60B0EA9DC61ADD8098C0694539EF + +Set 3, vector#174: + message=512-bit string: 21*00,02,42*00 + hash=75FDFFFAF4F1D44DD610CEDDB215E16593340EDE583C875A + +Set 3, vector#175: + message=512-bit string: 21*00,01,42*00 + hash=36EAA91B577FB20178B0F06FBF369D07FBCE8445BB36774D + +Set 3, vector#176: + message=512-bit string: 22*00,80,41*00 + hash=9068E188528160BC3B2C2036B4B6140BFCBC98A031847132 + +Set 3, vector#177: + message=512-bit string: 22*00,40,41*00 + hash=42E86596DB6EA0724CE131CC379F5A3F37646C87026DFB87 + +Set 3, vector#178: + message=512-bit string: 22*00,20,41*00 + hash=733642DD7D4F08A2303B7517974AC6D9E6EC65FBED56CB05 + +Set 3, vector#179: + message=512-bit string: 22*00,10,41*00 + hash=92ABCE48F750C364C5FC649E3E2168E5BE83F6176A2DC552 + +Set 3, vector#180: + message=512-bit string: 22*00,08,41*00 + hash=BB841126EBD38F36A63FDA47FD5971DFF6D9CF0432811535 + +Set 3, vector#181: + message=512-bit string: 22*00,04,41*00 + hash=1A5F8B7F34376121B1BA35FB19DD2DE6A1FFE55D22703940 + +Set 3, vector#182: + message=512-bit string: 22*00,02,41*00 + hash=A4705AA774708F6D6AEABD6B527C973DD3B955E144812BC5 + +Set 3, vector#183: + message=512-bit string: 22*00,01,41*00 + hash=ADA04C7993477041403A144C15BBFEE889A6F835B9F968DF + +Set 3, vector#184: + message=512-bit string: 23*00,80,40*00 + hash=2F4179071804EC9280CD2EA6E265AD77633F5196CF8EDB32 + +Set 3, vector#185: + message=512-bit string: 23*00,40,40*00 + hash=4378BD6082B465ADB4007CBDC5F764C402ADCBEE4347C08F + +Set 3, vector#186: + message=512-bit string: 23*00,20,40*00 + hash=F75B2A3267B96CA1EE4191B99CE78B079333F10EF184D91A + +Set 3, vector#187: + message=512-bit string: 23*00,10,40*00 + hash=C3891913D02202A3DFD2BFE70EDB992275744136452C566F + +Set 3, vector#188: + message=512-bit string: 23*00,08,40*00 + hash=07B465A5110B6F1D8CC50B4716A5B5CE9985CD0A7A857EAE + +Set 3, vector#189: + message=512-bit string: 23*00,04,40*00 + hash=AA3E818EDB7190F12AD58D9A4A9DAB53209AEE83F5B3C554 + +Set 3, vector#190: + message=512-bit string: 23*00,02,40*00 + hash=C570CAD73E05B2F8283A26726F07BAA339EE78ED7CA42F62 + +Set 3, vector#191: + message=512-bit string: 23*00,01,40*00 + hash=B48EC775851C9AE303F05AC8E51E62FF169C175792C2627A + +Set 3, vector#192: + message=512-bit string: 24*00,80,39*00 + hash=1E3047A18CCBA9F21D1E58F90FC2F8100D94227E29DF84A0 + +Set 3, vector#193: + message=512-bit string: 24*00,40,39*00 + hash=5CA88D9C7D388BCF7877FE0F8CDD5EC767DEC73783B60195 + +Set 3, vector#194: + message=512-bit string: 24*00,20,39*00 + hash=F0AFF7784660E13949EEBC8A817DB227D7DC2248EB0F659B + +Set 3, vector#195: + message=512-bit string: 24*00,10,39*00 + hash=9B5D9AB548CE2CB1B4F121B5BCACB724A02A655E56650014 + +Set 3, vector#196: + message=512-bit string: 24*00,08,39*00 + hash=DA5D70AC87DB9AB9A19D7E79FA3820B9A6855F148A662E9E + +Set 3, vector#197: + message=512-bit string: 24*00,04,39*00 + hash=0DA0AA0A4187C2AC05B220AB88498FC244FCEF7FCC59692A + +Set 3, vector#198: + message=512-bit string: 24*00,02,39*00 + hash=DEFC6E4E0FF252A652CAD76C06429D7D902F80D0C132EC2C + +Set 3, vector#199: + message=512-bit string: 24*00,01,39*00 + hash=FB8EA1191F9272038017D3D10B0F901514490B119C3C086F + +Set 3, vector#200: + message=512-bit string: 25*00,80,38*00 + hash=A0F433C8EF9F86EC52989CC77B999EA02827EA0D57F00766 + +Set 3, vector#201: + message=512-bit string: 25*00,40,38*00 + hash=73C51E27F033BDCF09E29C19740AC05676C7DA219C83F019 + +Set 3, vector#202: + message=512-bit string: 25*00,20,38*00 + hash=C1A41E1999A6E7ED8D2407005608A44999C0918F009F12BB + +Set 3, vector#203: + message=512-bit string: 25*00,10,38*00 + hash=C1DE2FB59A6A6CC45D3E1A9A502F0327E4E0582692882E01 + +Set 3, vector#204: + message=512-bit string: 25*00,08,38*00 + hash=FA371922F657875B03268090C91EF8A7D968486EFCBE853D + +Set 3, vector#205: + message=512-bit string: 25*00,04,38*00 + hash=D7786FFE8F9411E982D591C63A364483A733A005D8DD4F52 + +Set 3, vector#206: + message=512-bit string: 25*00,02,38*00 + hash=EA71A84A2AE43700E2D6CBF9705809F38EB01E3AA3500981 + +Set 3, vector#207: + message=512-bit string: 25*00,01,38*00 + hash=AEE84693BEA5105467DFFF30E694772F31148CCECA362D0B + +Set 3, vector#208: + message=512-bit string: 26*00,80,37*00 + hash=02C9565A480DFE315479D62BFFFF915768411199596D0067 + +Set 3, vector#209: + message=512-bit string: 26*00,40,37*00 + hash=0EA5DA49521F8C298EB3A65B157D3B0E42E0BDA0EED10EB3 + +Set 3, vector#210: + message=512-bit string: 26*00,20,37*00 + hash=A8F8E5533E0025DDF4421EA099D9C553736B86626649BFAC + +Set 3, vector#211: + message=512-bit string: 26*00,10,37*00 + hash=76D357BCB224F3B59DD6286A3EA0D4C2D09699E68ED7D4E3 + +Set 3, vector#212: + message=512-bit string: 26*00,08,37*00 + hash=202794850A8B2A8D611473C84F18835F322D32E04214502F + +Set 3, vector#213: + message=512-bit string: 26*00,04,37*00 + hash=1BED2B5DAA818E27EACA9EA5BC6B5D88FF7605CBC529C423 + +Set 3, vector#214: + message=512-bit string: 26*00,02,37*00 + hash=6FCEF79BBB8B556D597071E6E86815575C36955DB95FF0C9 + +Set 3, vector#215: + message=512-bit string: 26*00,01,37*00 + hash=5C76AF9054B56A78EE4BAE2F69E54EB4A4DCCA9251EC323F + +Set 3, vector#216: + message=512-bit string: 27*00,80,36*00 + hash=8645904A860B9227CC2EBE31269BCB033D12626D4E7B1E07 + +Set 3, vector#217: + message=512-bit string: 27*00,40,36*00 + hash=5CCAA2D96A4B90DD33CA1A8F63D9A32785FCE91FE9D261FE + +Set 3, vector#218: + message=512-bit string: 27*00,20,36*00 + hash=644AEF13CA34442715AF3B71F6F40863B9FE5B68D9AEA69D + +Set 3, vector#219: + message=512-bit string: 27*00,10,36*00 + hash=BB8F2FCECA6DBE2233D94CC9617C0C924251503E15ECBEFD + +Set 3, vector#220: + message=512-bit string: 27*00,08,36*00 + hash=C0CE5B9858DCAC7C2A7FD41EAD46C1D1F4A55C612EB87095 + +Set 3, vector#221: + message=512-bit string: 27*00,04,36*00 + hash=C3209B535B1893D292F24AA705A54AC6893F5C34DFC0B89B + +Set 3, vector#222: + message=512-bit string: 27*00,02,36*00 + hash=4A9362D913330BE01F8AA9A40621CF2BAE0AEE998182BFD8 + +Set 3, vector#223: + message=512-bit string: 27*00,01,36*00 + hash=6757B6725238FDF3AA6E92CE05242DC7A138F55A8A2B8CDF + +Set 3, vector#224: + message=512-bit string: 28*00,80,35*00 + hash=9C1EFCC39E943DB17478F55C2E8F5AABE665A257A74E7CC7 + +Set 3, vector#225: + message=512-bit string: 28*00,40,35*00 + hash=9E48EA08AF2BC00367D950D2A0BE14D0F26B71FBF3997B10 + +Set 3, vector#226: + message=512-bit string: 28*00,20,35*00 + hash=A6BBD6177AF40DDDCCF8CC8B8218833B8A89D6BE122E12AA + +Set 3, vector#227: + message=512-bit string: 28*00,10,35*00 + hash=F7BAE51827F6C16F31508A28D362DE9BA4984E47C88DC037 + +Set 3, vector#228: + message=512-bit string: 28*00,08,35*00 + hash=65DD7FF5BB8CE8D5F84480BF5A0E35127CD736A1CDE7BC12 + +Set 3, vector#229: + message=512-bit string: 28*00,04,35*00 + hash=E8531E2C7329ED60B7246E6246B1FEE13B1B70F1A119CE54 + +Set 3, vector#230: + message=512-bit string: 28*00,02,35*00 + hash=7B26F57EF6D56F8966AFB3AF6C9BCE1C1948396CE4FFB1F2 + +Set 3, vector#231: + message=512-bit string: 28*00,01,35*00 + hash=D6EFC3AD5E62E9055C414D01E11E0EC9374B5F4486AF92D9 + +Set 3, vector#232: + message=512-bit string: 29*00,80,34*00 + hash=B4000A22B7ECE2B3BC2695A2E98A9F4FC981DE2F44A80CA3 + +Set 3, vector#233: + message=512-bit string: 29*00,40,34*00 + hash=30F506642345E45D1116318D8F9849A640B13C27291F5B83 + +Set 3, vector#234: + message=512-bit string: 29*00,20,34*00 + hash=E02C8DBAAA96F301081E0F6F6FF3163D11B0340C5154E06D + +Set 3, vector#235: + message=512-bit string: 29*00,10,34*00 + hash=4D176A285408CA3E69FAA2F90B980CD10BED31F3B7C31F15 + +Set 3, vector#236: + message=512-bit string: 29*00,08,34*00 + hash=8BBECF1AAD25FDC805039E0B0AE53C72B2D598400FAD8A0F + +Set 3, vector#237: + message=512-bit string: 29*00,04,34*00 + hash=68213C2CB2C200AE8E130125F0DA1A81AF46DEA7A32564B0 + +Set 3, vector#238: + message=512-bit string: 29*00,02,34*00 + hash=B65CAE529F4F5640EC8E61D7B18DCABF5C42D09D16638E02 + +Set 3, vector#239: + message=512-bit string: 29*00,01,34*00 + hash=6D9BDF35483F61B8B41DF2BB3DAB479CE960916A91768BA9 + +Set 3, vector#240: + message=512-bit string: 30*00,80,33*00 + hash=C7065FCFBD627402B557D08EE245E4B792079CBA32E7E956 + +Set 3, vector#241: + message=512-bit string: 30*00,40,33*00 + hash=FA7CAC5FC22F2AF0FF1E052D28817A65966B2B0C1C2F8792 + +Set 3, vector#242: + message=512-bit string: 30*00,20,33*00 + hash=204A233E044B2C07EBBD2C529A8D578A07B21BB674EE4D64 + +Set 3, vector#243: + message=512-bit string: 30*00,10,33*00 + hash=5D64C8D0554606505D54BDF395D6608AE15D23144284C05F + +Set 3, vector#244: + message=512-bit string: 30*00,08,33*00 + hash=C90A9B1D92220CA0F3F4A8E65155FE0E1D152C89213E96D9 + +Set 3, vector#245: + message=512-bit string: 30*00,04,33*00 + hash=3C8673A6ED62C5FFC880D24A000053ED7042329424181DFF + +Set 3, vector#246: + message=512-bit string: 30*00,02,33*00 + hash=732D68C9AAEF89D27676A87AEA0F975BC31E9B7184AABE49 + +Set 3, vector#247: + message=512-bit string: 30*00,01,33*00 + hash=61D3540EF01107CBEDCA147F615B0DA929474344FA8DAB0D + +Set 3, vector#248: + message=512-bit string: 31*00,80,32*00 + hash=FBF56E336FF510ADA9A801F84E4792FD8E9B1C3B44B4D666 + +Set 3, vector#249: + message=512-bit string: 31*00,40,32*00 + hash=FD5EB3F4BF2E475CA451C856B2F576FCE1CAC3B700348176 + +Set 3, vector#250: + message=512-bit string: 31*00,20,32*00 + hash=E5D6F6AF3BB3D2D22975AB500DA24B5783E651C1AFADBCC1 + +Set 3, vector#251: + message=512-bit string: 31*00,10,32*00 + hash=22C7EFD25977630807C1D0FD7DC220FF426D589BEBF3F818 + +Set 3, vector#252: + message=512-bit string: 31*00,08,32*00 + hash=38C0B8ED87706F4A7C2DC5EADCD01C72193261CF37C196EF + +Set 3, vector#253: + message=512-bit string: 31*00,04,32*00 + hash=CAA17EB9893A85EBE650736A0B56FDCC9DDF6916707D1B99 + +Set 3, vector#254: + message=512-bit string: 31*00,02,32*00 + hash=1FC43409C387A59F2702D1120CA69AE1EB8BCC072AEBCC89 + +Set 3, vector#255: + message=512-bit string: 31*00,01,32*00 + hash=9D5CAD387705F97F784279C85B5C09D3A8216C3151BB8BB5 + +Set 3, vector#256: + message=512-bit string: 32*00,80,31*00 + hash=DC1EBB94F3E0E6703DAA5715A7E826554DB9EDE756B2EED2 + +Set 3, vector#257: + message=512-bit string: 32*00,40,31*00 + hash=5E626E0FBB4CAE926AC717EC009CAEE23B5CD3062359E20A + +Set 3, vector#258: + message=512-bit string: 32*00,20,31*00 + hash=F348BF048DB8D98D0BD0666B520AB255B12CA6047B3166AF + +Set 3, vector#259: + message=512-bit string: 32*00,10,31*00 + hash=8F929C79DDE5DE2794998170EFCABCE511637A29810ABF47 + +Set 3, vector#260: + message=512-bit string: 32*00,08,31*00 + hash=FE4661EE9DD9FD928D2AF9B5898EAEAB617E88369457DD67 + +Set 3, vector#261: + message=512-bit string: 32*00,04,31*00 + hash=6E0C9BCE677EA50439E02731B301300511643AC1FE00125D + +Set 3, vector#262: + message=512-bit string: 32*00,02,31*00 + hash=4589434D3BE9D44EF45DF1ED91AA97D812ED55DD869B9067 + +Set 3, vector#263: + message=512-bit string: 32*00,01,31*00 + hash=0C0DC9DAAD3351B7CE17F8D1F6DBDA62F91FCF6C93019C45 + +Set 3, vector#264: + message=512-bit string: 33*00,80,30*00 + hash=07FD597941C0A30A137256D65E5D2430EBA2C6EF24979E00 + +Set 3, vector#265: + message=512-bit string: 33*00,40,30*00 + hash=EEFC74ECC53C334768D59EEB02B49A462A976CAD32FA9F4C + +Set 3, vector#266: + message=512-bit string: 33*00,20,30*00 + hash=292EE351E25622EF85A07C0C161FC0FBC09229C176998D35 + +Set 3, vector#267: + message=512-bit string: 33*00,10,30*00 + hash=7ED81D7B5AD71E60F04E388D2E29E044EE253D701D213ED1 + +Set 3, vector#268: + message=512-bit string: 33*00,08,30*00 + hash=56A2F7E6F85975BFCE0705A124AE4CBF7C3015690304521D + +Set 3, vector#269: + message=512-bit string: 33*00,04,30*00 + hash=B07EA50183596A2430F3DEC13F96845D1070A3D32F5EC066 + +Set 3, vector#270: + message=512-bit string: 33*00,02,30*00 + hash=526F6BBF1EBE525ECF7EFBE693A06B746307726F2011529C + +Set 3, vector#271: + message=512-bit string: 33*00,01,30*00 + hash=89EBE9219A9AC412BEC88BA321030B4AAA257B6410F7719B + +Set 3, vector#272: + message=512-bit string: 34*00,80,29*00 + hash=ABD5FE2E6DA870D5B894B35E72E41D590A01E40303524335 + +Set 3, vector#273: + message=512-bit string: 34*00,40,29*00 + hash=1E3D537D9580A74F2D7FC71EE241923AB3848D11A1A5644C + +Set 3, vector#274: + message=512-bit string: 34*00,20,29*00 + hash=F580664AB99A6B50BFA21019261D91B3A1238FB129B0797A + +Set 3, vector#275: + message=512-bit string: 34*00,10,29*00 + hash=2DB79D2513802F939D4608E4FFE38D1CD5FFE7B667CE3EEC + +Set 3, vector#276: + message=512-bit string: 34*00,08,29*00 + hash=13B1F534DACAC2836C67B4B410151AE550AFF9C977B6A3D5 + +Set 3, vector#277: + message=512-bit string: 34*00,04,29*00 + hash=86ABFE6988DFE9D6C9A884942946BE74115987EA3C6AF477 + +Set 3, vector#278: + message=512-bit string: 34*00,02,29*00 + hash=9FB58A6C6822D1F7BF3AC52BD210132FD6DD1E823D3CE95C + +Set 3, vector#279: + message=512-bit string: 34*00,01,29*00 + hash=1F5E0C29EBE8A28B934E7932C0D120F2F01CFA87DC089E0C + +Set 3, vector#280: + message=512-bit string: 35*00,80,28*00 + hash=BEA84869592DF1FD12127F891CA9DAFEE767226868F878DB + +Set 3, vector#281: + message=512-bit string: 35*00,40,28*00 + hash=6FC0DF95D191F492399AFC32C4F536F43C14E189DA93396C + +Set 3, vector#282: + message=512-bit string: 35*00,20,28*00 + hash=33E9415EA0EDB2BAC1DD210B9CC2F5D7F46B5B07C5EFCC3F + +Set 3, vector#283: + message=512-bit string: 35*00,10,28*00 + hash=CD933BE80058AFBBC9FFD6590CA2F53B3696E7F86CBDE8CD + +Set 3, vector#284: + message=512-bit string: 35*00,08,28*00 + hash=15F89B44FF00A4CB930233FADB49A824F0AB540636A0E8A5 + +Set 3, vector#285: + message=512-bit string: 35*00,04,28*00 + hash=33C345BFFA20C8F0B92AC6F3F063E477F1CDA525C35E68AB + +Set 3, vector#286: + message=512-bit string: 35*00,02,28*00 + hash=617EE74C600A5B9D5C591984222DC000642FA97ECAF6948F + +Set 3, vector#287: + message=512-bit string: 35*00,01,28*00 + hash=E50FF576A78A5FF73038F307740FFB190F405AAF65909C7B + +Set 3, vector#288: + message=512-bit string: 36*00,80,27*00 + hash=10F16B3B9BE9762F603DC156A2626D0A92C49D6788433292 + +Set 3, vector#289: + message=512-bit string: 36*00,40,27*00 + hash=65C75607C3085EE0DF99AC88FCB71FEEA3E95D1995027B90 + +Set 3, vector#290: + message=512-bit string: 36*00,20,27*00 + hash=A95A236CEAA6FE6A33DBD6B2FF2CC61DCD06B576D34D8BF9 + +Set 3, vector#291: + message=512-bit string: 36*00,10,27*00 + hash=94701D90637F543B83AC736D448D915AB56ACF688AA2A9BF + +Set 3, vector#292: + message=512-bit string: 36*00,08,27*00 + hash=C005D8C2069CB7F291C7214165383ECC418999FADF197ED3 + +Set 3, vector#293: + message=512-bit string: 36*00,04,27*00 + hash=F02715BA20879FE16CA382F3F33B35DA09273F524A832CE0 + +Set 3, vector#294: + message=512-bit string: 36*00,02,27*00 + hash=925F4C6B45F07D01F1033AE426E554FE30AD5664F89EB521 + +Set 3, vector#295: + message=512-bit string: 36*00,01,27*00 + hash=DA89E876647B2B17B726DABF0620B5791B8D910CB9E7323D + +Set 3, vector#296: + message=512-bit string: 37*00,80,26*00 + hash=A3817AEC34558CE5C4554B4BB652D52E0FB834D66173B40A + +Set 3, vector#297: + message=512-bit string: 37*00,40,26*00 + hash=EC4599DB388F66C10AF7C24987AAAB6D02CF431602C321D3 + +Set 3, vector#298: + message=512-bit string: 37*00,20,26*00 + hash=D7BBCCC448440CD6BFF93D8CA1DC309BE47E51C823B85EBB + +Set 3, vector#299: + message=512-bit string: 37*00,10,26*00 + hash=2CAB4F11BE0BB64B4F16F707DF30F465A279C6972FBCD7D9 + +Set 3, vector#300: + message=512-bit string: 37*00,08,26*00 + hash=12E4D1EF75CBCA5369EB440776F117EDA8B536A35C26F139 + +Set 3, vector#301: + message=512-bit string: 37*00,04,26*00 + hash=17444B27596CBC519FBC8F2B90D68D05BCF51608ACC3D304 + +Set 3, vector#302: + message=512-bit string: 37*00,02,26*00 + hash=D76A8B2E986EB16CD6121CED58295F0CF5EB02DEB60F98CC + +Set 3, vector#303: + message=512-bit string: 37*00,01,26*00 + hash=164E3829B70E59570D2A5B24A0F1C67A974DFFF1EF5BF2EA + +Set 3, vector#304: + message=512-bit string: 38*00,80,25*00 + hash=0EE8B5DD7E5A285EBE11965B574517B949C3487937453B2B + +Set 3, vector#305: + message=512-bit string: 38*00,40,25*00 + hash=E3639D864D20ECB48D8C2B8F892D97A7FECF83937C48C2DC + +Set 3, vector#306: + message=512-bit string: 38*00,20,25*00 + hash=4434C996B25FE43CA24746396E50C157139C57787675CE17 + +Set 3, vector#307: + message=512-bit string: 38*00,10,25*00 + hash=6D1693269BBA7630B6C083EA6D8AA16F0512F07C214251A9 + +Set 3, vector#308: + message=512-bit string: 38*00,08,25*00 + hash=A1D5C7ABDDF9FA51FB5C9AE0008FA953EA83063C93E49319 + +Set 3, vector#309: + message=512-bit string: 38*00,04,25*00 + hash=9BAC4A7FFF14B34F32F10EB2B6A3A61A13C255DB176D6FCB + +Set 3, vector#310: + message=512-bit string: 38*00,02,25*00 + hash=C6BD779EE2F9FF6A4ACCDA2E33FD0C62D641733E414D5B36 + +Set 3, vector#311: + message=512-bit string: 38*00,01,25*00 + hash=F0D656506DE265EC28F1781DACB76D1C7575DC55C15A40DC + +Set 3, vector#312: + message=512-bit string: 39*00,80,24*00 + hash=0E95FD14633037441CD9AFE78391FFE73AAFEFE532B8F7D6 + +Set 3, vector#313: + message=512-bit string: 39*00,40,24*00 + hash=AFA01B52D549FF4C8B6DC71BBA6CFA27E8EA03046B95F6EF + +Set 3, vector#314: + message=512-bit string: 39*00,20,24*00 + hash=9E63417D3DF651A3353FB6573FFAED9DF4ABD7F68AAAA051 + +Set 3, vector#315: + message=512-bit string: 39*00,10,24*00 + hash=CE51254F812107B91727838B619D5C4F17FC2C3C9A95233A + +Set 3, vector#316: + message=512-bit string: 39*00,08,24*00 + hash=89F63C422BB85635F432D4A6DC9F940D79E0B5E111A24F4E + +Set 3, vector#317: + message=512-bit string: 39*00,04,24*00 + hash=999534C4B3B25F32FFF05B893F4E26CF8F1819FCB5B908C1 + +Set 3, vector#318: + message=512-bit string: 39*00,02,24*00 + hash=7FAACB92FEFD12045C77B4180EA95EE7E1775703E7BB4C3E + +Set 3, vector#319: + message=512-bit string: 39*00,01,24*00 + hash=2BFEAD2B7E1C6BB0F47AEFB9909E3ED961EFB39A29794515 + +Set 3, vector#320: + message=512-bit string: 40*00,80,23*00 + hash=A52AE6D0221773E42FB042B7830D28A73A590562C38C802B + +Set 3, vector#321: + message=512-bit string: 40*00,40,23*00 + hash=5B3007DFB62B78955620A0F17F58B6FE55B360C0F7A9F4C3 + +Set 3, vector#322: + message=512-bit string: 40*00,20,23*00 + hash=77883951F130BA75FED13621DC61BB766E475DB7751B0D3B + +Set 3, vector#323: + message=512-bit string: 40*00,10,23*00 + hash=297DEB90367720058318C994C0382B83D182110797A29A53 + +Set 3, vector#324: + message=512-bit string: 40*00,08,23*00 + hash=0BA968080D4608C3BFBE43682CBBD63F246F866AB0A0070C + +Set 3, vector#325: + message=512-bit string: 40*00,04,23*00 + hash=328F20CDFFD905862A11F70B6FDB4803133CCE8ABB8D2B73 + +Set 3, vector#326: + message=512-bit string: 40*00,02,23*00 + hash=74AC023139CF3557F49E2F8A674AD0857AEEB9EBA3C1985C + +Set 3, vector#327: + message=512-bit string: 40*00,01,23*00 + hash=BD588F19DC358DC37450A6689E4D7DA413206159F3DD2A4D + +Set 3, vector#328: + message=512-bit string: 41*00,80,22*00 + hash=DB626F5040AF44803156FF86860A1367B1B644B021C15460 + +Set 3, vector#329: + message=512-bit string: 41*00,40,22*00 + hash=ADE8785F2F65B67ED1740F8693C5A1CB3BFEE9E3B211B83D + +Set 3, vector#330: + message=512-bit string: 41*00,20,22*00 + hash=D08599E7444393A3C5FF2493E1B6647B297708919163E05B + +Set 3, vector#331: + message=512-bit string: 41*00,10,22*00 + hash=8AA57D3CCCB899CC92A44ACE801F54A13E60A45BFDFE7D30 + +Set 3, vector#332: + message=512-bit string: 41*00,08,22*00 + hash=3415A0699A0D14DBBBB2280A9C8E3C91B954B769CE606362 + +Set 3, vector#333: + message=512-bit string: 41*00,04,22*00 + hash=EAD03B5ACC5C86FC8672AE14330BF93A9489A5017D3B9354 + +Set 3, vector#334: + message=512-bit string: 41*00,02,22*00 + hash=7ABE3B7FD5804A23B937C0EF5ADD8869188BF842F68D21F5 + +Set 3, vector#335: + message=512-bit string: 41*00,01,22*00 + hash=739004F8FC7577D0BA954187F300E441F4A99F62E0F3C367 + +Set 3, vector#336: + message=512-bit string: 42*00,80,21*00 + hash=30D99CB386570F45B8F0EB75868E8EA9EC7DBB04C26D8FEA + +Set 3, vector#337: + message=512-bit string: 42*00,40,21*00 + hash=7278F6E780965FB5C02AC4AC24BD2020D2439623EEB901C8 + +Set 3, vector#338: + message=512-bit string: 42*00,20,21*00 + hash=93E7E84B803152CE17491B9B9DC6502041DA4D56C636B4A7 + +Set 3, vector#339: + message=512-bit string: 42*00,10,21*00 + hash=32D63F3C642173BDE55C2A7E8BB6C942420C309DB2E7210A + +Set 3, vector#340: + message=512-bit string: 42*00,08,21*00 + hash=CECC92727AAEE2FA74B90AA728F0D3F0FC5E8A42DF283713 + +Set 3, vector#341: + message=512-bit string: 42*00,04,21*00 + hash=51437CED5761BC3FCF29FDE5877675B5DCCABC85BC2279B8 + +Set 3, vector#342: + message=512-bit string: 42*00,02,21*00 + hash=F6A494D7241543CBFE2BB3C68F2DA9FD9915BF0A14BF82F4 + +Set 3, vector#343: + message=512-bit string: 42*00,01,21*00 + hash=DD8BE4ED5FFCF836C977352ECD2CF689BD94F9CF0EB66EB4 + +Set 3, vector#344: + message=512-bit string: 43*00,80,20*00 + hash=1EF1B22652B07E0039DC257B30E88A2FA5D3FC64C79C741C + +Set 3, vector#345: + message=512-bit string: 43*00,40,20*00 + hash=775E4B0447AFD1C960320C042EF2AB6C879088956435872E + +Set 3, vector#346: + message=512-bit string: 43*00,20,20*00 + hash=A40FB52C188AAC639CF9ECE72B978C812CA7991997CCC3D0 + +Set 3, vector#347: + message=512-bit string: 43*00,10,20*00 + hash=F6F305D3ACA46CEFDA5FCF420B49C9C13F14C3247E4214AB + +Set 3, vector#348: + message=512-bit string: 43*00,08,20*00 + hash=2A5611447591A609BEDB9B99AF030D1548C25C1090FB7252 + +Set 3, vector#349: + message=512-bit string: 43*00,04,20*00 + hash=6BB8BF7CF510DF644EA1771146EC6E943E26598734BB2022 + +Set 3, vector#350: + message=512-bit string: 43*00,02,20*00 + hash=8508F80824415D97E468B19EA305B0473A915B996DC83A31 + +Set 3, vector#351: + message=512-bit string: 43*00,01,20*00 + hash=8814EE7A02164290EB431E70D50490DC2313BD30EB479857 + +Set 3, vector#352: + message=512-bit string: 44*00,80,19*00 + hash=EFD4A311C5F5093AB23F2C775577EEEE230643A75F7938C6 + +Set 3, vector#353: + message=512-bit string: 44*00,40,19*00 + hash=6FA980DE170E4708F4F59BA46DE0EA340BC61C540B0D12BD + +Set 3, vector#354: + message=512-bit string: 44*00,20,19*00 + hash=C699821C7E342804278CA77879FFB9332F274530C673385F + +Set 3, vector#355: + message=512-bit string: 44*00,10,19*00 + hash=FCFA7BA4FE1736CA672914AC98905FCF235CB82F10BE9981 + +Set 3, vector#356: + message=512-bit string: 44*00,08,19*00 + hash=BB1DC4CAA892B46D15C44125DEDF64C63EC4DE5B807F93DF + +Set 3, vector#357: + message=512-bit string: 44*00,04,19*00 + hash=520F25FEEC8D698D31C164D291A54B906564A75B7B693239 + +Set 3, vector#358: + message=512-bit string: 44*00,02,19*00 + hash=772CB58B4086454862B813AB25EA5E33BE530D3DF48F8BD5 + +Set 3, vector#359: + message=512-bit string: 44*00,01,19*00 + hash=CBDBBF709ADE1701ABDA7A258528D675B505678E6B643FDD + +Set 3, vector#360: + message=512-bit string: 45*00,80,18*00 + hash=A16CEC411677F88C1F751442BCDBC9F013AA1F4E829CFCA8 + +Set 3, vector#361: + message=512-bit string: 45*00,40,18*00 + hash=9DA04A1EF52DDF86660B9EA7D8AF385BBE6369B10AF2F3B3 + +Set 3, vector#362: + message=512-bit string: 45*00,20,18*00 + hash=049F7036F40FB51260E4B8CB0696EA03D375B401CED3E2C7 + +Set 3, vector#363: + message=512-bit string: 45*00,10,18*00 + hash=EEB8208784C4C65DA497729C948063BD9F51FE5C026CBC8B + +Set 3, vector#364: + message=512-bit string: 45*00,08,18*00 + hash=F39BA71DFAD235C2E0CC8BBAE4CD8D5D1EEE9247086ECAEE + +Set 3, vector#365: + message=512-bit string: 45*00,04,18*00 + hash=8372D7953F7697BE48661E3718196082B06EB448EDF3D839 + +Set 3, vector#366: + message=512-bit string: 45*00,02,18*00 + hash=D41785ADE9E2FFCAA5B9D44613CD23CD9C3A519CD9C89BED + +Set 3, vector#367: + message=512-bit string: 45*00,01,18*00 + hash=620D6396A467CB957740B85D5D51E53279DF78D56D6CE8B6 + +Set 3, vector#368: + message=512-bit string: 46*00,80,17*00 + hash=89905029EF0112631ED9DFDEB63BA26235B822022B686D59 + +Set 3, vector#369: + message=512-bit string: 46*00,40,17*00 + hash=51AD7F7D9611ED7C24A84525832A2F8CFAB80F907C02533E + +Set 3, vector#370: + message=512-bit string: 46*00,20,17*00 + hash=C645E4CF66DA4B343FC0E9221B4616E8CAE1E65E50195E64 + +Set 3, vector#371: + message=512-bit string: 46*00,10,17*00 + hash=38EB1AAA6CEBBE8A21EBBB9C0976D29F4089EE47ED1D1F4E + +Set 3, vector#372: + message=512-bit string: 46*00,08,17*00 + hash=EDF66F50CD0F54FB3094E3412E28177A53B1CE56D0FDE4E8 + +Set 3, vector#373: + message=512-bit string: 46*00,04,17*00 + hash=11CD219A1E03532D2D4D61F1563C2AAA8A1586736FEB5CA0 + +Set 3, vector#374: + message=512-bit string: 46*00,02,17*00 + hash=01D50B226A3517A3DCE79495FE1410E7AB6FEEAF8FA24BB7 + +Set 3, vector#375: + message=512-bit string: 46*00,01,17*00 + hash=F981D517F259B363A945D2D19447378649E597A37641B911 + +Set 3, vector#376: + message=512-bit string: 47*00,80,16*00 + hash=B36A8BB7E4018ADB5DC72B4961501F9A5AD5931F5E97A6D6 + +Set 3, vector#377: + message=512-bit string: 47*00,40,16*00 + hash=D78D1E9D4682A0777A6EC0D8C2F165CAB925966650937F89 + +Set 3, vector#378: + message=512-bit string: 47*00,20,16*00 + hash=2F6D9783D5BF5976DCC31C7F00B9FCD04B6C16BE92417C9B + +Set 3, vector#379: + message=512-bit string: 47*00,10,16*00 + hash=22B9F7C41FCE5A4638D6E6C61265B58D18C2D5FBBE33E9F4 + +Set 3, vector#380: + message=512-bit string: 47*00,08,16*00 + hash=37B7BA6658F835D817CB114D06C197D23C47708352EAC551 + +Set 3, vector#381: + message=512-bit string: 47*00,04,16*00 + hash=D8E97C4A5F14A1F595C041D0ED59C4D4631E7AB673484824 + +Set 3, vector#382: + message=512-bit string: 47*00,02,16*00 + hash=AC782146178A613B3FEA97DBF2018A6C7E1EE3789BBE2A51 + +Set 3, vector#383: + message=512-bit string: 47*00,01,16*00 + hash=11FD098F69CA3BE809474769C7DC6664A37AA26358A1EF08 + +Set 3, vector#384: + message=512-bit string: 48*00,80,15*00 + hash=93856CBBE6404B2EF9D4240556810833C73D6D049FCA47BB + +Set 3, vector#385: + message=512-bit string: 48*00,40,15*00 + hash=C8466665EA45CE4CFD88F819D5C639777640B84D3D60C4BF + +Set 3, vector#386: + message=512-bit string: 48*00,20,15*00 + hash=9B4834F18ED69D519D497AD84204BCB9D749F122A86206F1 + +Set 3, vector#387: + message=512-bit string: 48*00,10,15*00 + hash=7571A4B267EB04E445803700DB6A72242E1DE16B1677C410 + +Set 3, vector#388: + message=512-bit string: 48*00,08,15*00 + hash=2A6518AF7D1C26F81852CABD90366371783BE49E94BEA42F + +Set 3, vector#389: + message=512-bit string: 48*00,04,15*00 + hash=AEBDEE389CEE275743FD1DFE10716DA734049874700D55C1 + +Set 3, vector#390: + message=512-bit string: 48*00,02,15*00 + hash=8EF1808D19882CCB413F4B432918984BFE61D3419999642E + +Set 3, vector#391: + message=512-bit string: 48*00,01,15*00 + hash=26B8CC222AA5C53969D3DB6DA64743B71063AE978E1F5899 + +Set 3, vector#392: + message=512-bit string: 49*00,80,14*00 + hash=2B8FA32B543ED0E1A8EED1165806602675D21D4A330AACD5 + +Set 3, vector#393: + message=512-bit string: 49*00,40,14*00 + hash=7BBD8EB068F2EFB116AC6EF6FE80BFB0E8023702D17EFA6E + +Set 3, vector#394: + message=512-bit string: 49*00,20,14*00 + hash=344265DD1FEEE145A37F268EF0877581998CF323CFECECCA + +Set 3, vector#395: + message=512-bit string: 49*00,10,14*00 + hash=9B606437205BD1DB249D3566D7AEE9D289C9CFD0D57FD058 + +Set 3, vector#396: + message=512-bit string: 49*00,08,14*00 + hash=C28D239C59BD76719345840E7C491748FAE7FCBC5EEA6C51 + +Set 3, vector#397: + message=512-bit string: 49*00,04,14*00 + hash=BD1EFD0CFD6283ACD2A95B1DAE33ACC47A14D21AE3A74DF1 + +Set 3, vector#398: + message=512-bit string: 49*00,02,14*00 + hash=B0EEE8E5A9256A73A98B641F3D29092D2F1F1B75509F5455 + +Set 3, vector#399: + message=512-bit string: 49*00,01,14*00 + hash=C46B3EB0F3B3C6D61CF0E5A263D4499A91D68055B1EB4996 + +Set 3, vector#400: + message=512-bit string: 50*00,80,13*00 + hash=C14215E03D57E2D109D88F48500F0D2332A819F1716D8885 + +Set 3, vector#401: + message=512-bit string: 50*00,40,13*00 + hash=DD38ABA719EEB2B7B78DD4455AB2DF07A5DA8608BC8250EC + +Set 3, vector#402: + message=512-bit string: 50*00,20,13*00 + hash=1175351A36F8F2769BA8A206185C10B241189FA4D6220C83 + +Set 3, vector#403: + message=512-bit string: 50*00,10,13*00 + hash=208DC327BC1BE3B55EFDEFEF89776DA5EA979CA479CC970C + +Set 3, vector#404: + message=512-bit string: 50*00,08,13*00 + hash=AD80043313C929A421495430561C49F0613C195D3578B518 + +Set 3, vector#405: + message=512-bit string: 50*00,04,13*00 + hash=8384691A0DCADD919AB610D69A4C478A582525D5C48B7F17 + +Set 3, vector#406: + message=512-bit string: 50*00,02,13*00 + hash=2FF93D872E9E6AE1783C0EF5B1AB9510050F0276563BA02F + +Set 3, vector#407: + message=512-bit string: 50*00,01,13*00 + hash=D3C7B2D23986E191D95B19810843B63360578024F3272DA9 + +Set 3, vector#408: + message=512-bit string: 51*00,80,12*00 + hash=29F56FA57392FF312289DF4A88C718FA56D2C3357FE6D0D8 + +Set 3, vector#409: + message=512-bit string: 51*00,40,12*00 + hash=175884C528D5584EF0E0AAB61660EB9684242F00F6911A24 + +Set 3, vector#410: + message=512-bit string: 51*00,20,12*00 + hash=F5D5EE0BFBF2186BD6CE3C63A9E19852EFF62D39E8215068 + +Set 3, vector#411: + message=512-bit string: 51*00,10,12*00 + hash=6712197F2D9E424139C93292E9B684A11579BAD5546A9F99 + +Set 3, vector#412: + message=512-bit string: 51*00,08,12*00 + hash=EDAFE550B5634A040E23A008DD3B15C476907B3CD596725B + +Set 3, vector#413: + message=512-bit string: 51*00,04,12*00 + hash=230EC8B2DDCE48BB1ED8928509CE6659981DB303813C7031 + +Set 3, vector#414: + message=512-bit string: 51*00,02,12*00 + hash=02371A2CA23F8781DCCBA0672C979EBF0EA8F17F4CAAB443 + +Set 3, vector#415: + message=512-bit string: 51*00,01,12*00 + hash=E0EFB4CE4025CD25C760F9E822F954D6B38319E71ABED25E + +Set 3, vector#416: + message=512-bit string: 52*00,80,11*00 + hash=2030785CC6D18999182F7B6A9BCA9F72F86829F89B306C37 + +Set 3, vector#417: + message=512-bit string: 52*00,40,11*00 + hash=3490EBCD433D9FDA74EAAD97469345846E190540C6D82642 + +Set 3, vector#418: + message=512-bit string: 52*00,20,11*00 + hash=A9C3E5AB60F1666619A899B8F3AC2370A5BF2298B99BADBB + +Set 3, vector#419: + message=512-bit string: 52*00,10,11*00 + hash=804320365682196340806665DC55299041D3BD85728BA0F2 + +Set 3, vector#420: + message=512-bit string: 52*00,08,11*00 + hash=53A2DF8B0C83C7120BE2A9608F1B5A4528BEFEC9D7970487 + +Set 3, vector#421: + message=512-bit string: 52*00,04,11*00 + hash=2BCD607D529B39E1429F0C54B94ED78F826389086C7739C8 + +Set 3, vector#422: + message=512-bit string: 52*00,02,11*00 + hash=0C466A6ACFA584D239367547536323A32715D0DBB5867B0E + +Set 3, vector#423: + message=512-bit string: 52*00,01,11*00 + hash=2FC3EA605A33AC26E78D8CA19F98CE7B5827E62961D89212 + +Set 3, vector#424: + message=512-bit string: 53*00,80,10*00 + hash=8761107DC3785DBF710BBBEDE5FEABAB6F175A5ECFA961B3 + +Set 3, vector#425: + message=512-bit string: 53*00,40,10*00 + hash=F123F30881EC794674403328E3CE7C80BC95DAC12D7B360B + +Set 3, vector#426: + message=512-bit string: 53*00,20,10*00 + hash=341C9DADB601F2781F6ABEB933B73AAD103A81E8D96F6730 + +Set 3, vector#427: + message=512-bit string: 53*00,10,10*00 + hash=38E53597534CCF0E60DA817C62924453E193D61861043244 + +Set 3, vector#428: + message=512-bit string: 53*00,08,10*00 + hash=3DF84CC5EDC3D732948BE841302B9AB708F5AF33DC537A31 + +Set 3, vector#429: + message=512-bit string: 53*00,04,10*00 + hash=B546891818224B14E90827757DE18BABD71449E57F8FCFF1 + +Set 3, vector#430: + message=512-bit string: 53*00,02,10*00 + hash=A7D6E7A48C1C14CD8DC58D7EFCD4FC8D407F15A1D4AA41D5 + +Set 3, vector#431: + message=512-bit string: 53*00,01,10*00 + hash=0B178B35A97C06D9D4D2A5838AA867BFDBDB36D674AF33D0 + +Set 3, vector#432: + message=512-bit string: 54*00,80, 9*00 + hash=8C22DFD72E5ECBA3D0E0B54985D01223032939E7B7B33697 + +Set 3, vector#433: + message=512-bit string: 54*00,40, 9*00 + hash=A52E67BE70E116BDF6EB61EF225DB94DF06966203DFA2E31 + +Set 3, vector#434: + message=512-bit string: 54*00,20, 9*00 + hash=4AB1B7BAD46AF64C8B6203A8889CF56A079F18F688790896 + +Set 3, vector#435: + message=512-bit string: 54*00,10, 9*00 + hash=65D1A4BF8DBA94C9752913A4C15FCFB7F18CCF257D48DED6 + +Set 3, vector#436: + message=512-bit string: 54*00,08, 9*00 + hash=090CFB92322D482D9D8AAFF716F10FDB491BE0FAF50C784F + +Set 3, vector#437: + message=512-bit string: 54*00,04, 9*00 + hash=94F1F66FB01D719F04D36CA30287F7E534DC31B0D91CE1FE + +Set 3, vector#438: + message=512-bit string: 54*00,02, 9*00 + hash=D8689D811424A59B870F84D11BFA1D202BF57896154405B6 + +Set 3, vector#439: + message=512-bit string: 54*00,01, 9*00 + hash=D7F2171F5B7523C54B4D1A81BB6048C99CED1E15087A9C49 + +Set 3, vector#440: + message=512-bit string: 55*00,80, 8*00 + hash=94DC8F6AAAD2A07CA81191B613291EB06EEC66A1B628F9CC + +Set 3, vector#441: + message=512-bit string: 55*00,40, 8*00 + hash=534D75114EB28DFE082BBA4285ED30E55CBE4864278FF182 + +Set 3, vector#442: + message=512-bit string: 55*00,20, 8*00 + hash=F5971C8523421B68BC3D9FCA5ADC5D2C76CD0C3797232950 + +Set 3, vector#443: + message=512-bit string: 55*00,10, 8*00 + hash=D274B834360952A27265C12C2B70623CDCB69C4815B8AD9E + +Set 3, vector#444: + message=512-bit string: 55*00,08, 8*00 + hash=D25074898E465F024B7D5AA542575176B885998694BFF162 + +Set 3, vector#445: + message=512-bit string: 55*00,04, 8*00 + hash=100B09B1A2778E07F0DEE2E6DFB28D032FA35D7EBAB2E87A + +Set 3, vector#446: + message=512-bit string: 55*00,02, 8*00 + hash=96FE586BD7D472FFA884C5724561D517C1126957FB190096 + +Set 3, vector#447: + message=512-bit string: 55*00,01, 8*00 + hash=45EE36AF320341688173D7C41A7615BCCD0A431F834EFD18 + +Set 3, vector#448: + message=512-bit string: 56*00,80, 7*00 + hash=F73847AEB45D714CC5756DBDEE00A9E580EF91101AC8FE64 + +Set 3, vector#449: + message=512-bit string: 56*00,40, 7*00 + hash=30A56E8B8CDAD753A854A1BE4B61DB04F303B6CFD0D76522 + +Set 3, vector#450: + message=512-bit string: 56*00,20, 7*00 + hash=1BADACF65A1F790B448DF08A100E66CDB8B404DDC7865016 + +Set 3, vector#451: + message=512-bit string: 56*00,10, 7*00 + hash=D0DA13AA2AFC006A97C537541B505B96CE798BDDC07B9D6D + +Set 3, vector#452: + message=512-bit string: 56*00,08, 7*00 + hash=FB4170AA2DBAA3844FD8485D4325BE987E2E589B58AB3B80 + +Set 3, vector#453: + message=512-bit string: 56*00,04, 7*00 + hash=50A0FE8090A0AA2EA503CD40DBE894004852584FDE11E3E2 + +Set 3, vector#454: + message=512-bit string: 56*00,02, 7*00 + hash=F6311445087C56C3CA179EF211FD32762134EDC910D9270B + +Set 3, vector#455: + message=512-bit string: 56*00,01, 7*00 + hash=A292F008A7BDF88E61FF866269A6D6F6AC9A81F706D57C27 + +Set 3, vector#456: + message=512-bit string: 57*00,80, 6*00 + hash=700C29CF917F3634215C58B9B3B9C147FC0AEA52C05B2841 + +Set 3, vector#457: + message=512-bit string: 57*00,40, 6*00 + hash=2071C5313B0EA39ECC258AC29ED6E6CA8E0511C726A528A9 + +Set 3, vector#458: + message=512-bit string: 57*00,20, 6*00 + hash=AC6F08712123FF72E9C04D1C5C343BC2A356DBEE9223B8E8 + +Set 3, vector#459: + message=512-bit string: 57*00,10, 6*00 + hash=01F46A7935579B7A7F5CDD00B5E7F1D62C37726F4216DC1D + +Set 3, vector#460: + message=512-bit string: 57*00,08, 6*00 + hash=820320BBB243E30FE35395FBFAF46A5C8C0CA41E4B48A80B + +Set 3, vector#461: + message=512-bit string: 57*00,04, 6*00 + hash=4B3365B4AF9E0C1AB703F297ECB82F9DB6ED44819DBC72F8 + +Set 3, vector#462: + message=512-bit string: 57*00,02, 6*00 + hash=DF69D9A819C4E27ED1B7D66678FDEBD8BBD1747F892D2B55 + +Set 3, vector#463: + message=512-bit string: 57*00,01, 6*00 + hash=C0F17FAF958767C65EBA2F68EE245205CB1BB73290AACAB6 + +Set 3, vector#464: + message=512-bit string: 58*00,80, 5*00 + hash=D62C3EBC661115CDE4F4BD646D745ADB7225304D2712837D + +Set 3, vector#465: + message=512-bit string: 58*00,40, 5*00 + hash=37E9A837E07B12281F4740D8353DD6008A077F6EF51978B9 + +Set 3, vector#466: + message=512-bit string: 58*00,20, 5*00 + hash=9826470A5ABEE6EE66BB799C9A9206703174AB77AA6223A4 + +Set 3, vector#467: + message=512-bit string: 58*00,10, 5*00 + hash=506C60EAC24C18D955364759BD8CD522157AD658C7B1652E + +Set 3, vector#468: + message=512-bit string: 58*00,08, 5*00 + hash=110923F8A4E154057211F273FDAF0F565AAD0A0962C4E08D + +Set 3, vector#469: + message=512-bit string: 58*00,04, 5*00 + hash=30CE0B97A6578CE2398BF04E63F78B2CAB5DC97A140426CE + +Set 3, vector#470: + message=512-bit string: 58*00,02, 5*00 + hash=3AE75A6039177B44B18B2C02EE148388F93E6EB96A989D3D + +Set 3, vector#471: + message=512-bit string: 58*00,01, 5*00 + hash=0DE8D7C180C5FB4E90ECF4165EECEDE97316170B7B00D681 + +Set 3, vector#472: + message=512-bit string: 59*00,80, 4*00 + hash=A1BA31195FF34A411C5D9A72A84C83C7BD7C6C777FC7DA4A + +Set 3, vector#473: + message=512-bit string: 59*00,40, 4*00 + hash=1D7295FE7B297D4B752159B7DD71483D53C7799FF82054E4 + +Set 3, vector#474: + message=512-bit string: 59*00,20, 4*00 + hash=F0210F4416BE56B157EDC9A76684D1F1653EFA6B7D06079B + +Set 3, vector#475: + message=512-bit string: 59*00,10, 4*00 + hash=311229D7C5AADF9CAA0DF39E441D4E119D0B3887194B9751 + +Set 3, vector#476: + message=512-bit string: 59*00,08, 4*00 + hash=7E5E875547284EE4952C250DA3BB4E3BBE59086FA638CAAE + +Set 3, vector#477: + message=512-bit string: 59*00,04, 4*00 + hash=890371D12AF03062698C2F4F5F2D7272DF652EE99C4233B3 + +Set 3, vector#478: + message=512-bit string: 59*00,02, 4*00 + hash=BD3F48F09AB50132242F762A61904E945CD3628A925A8B82 + +Set 3, vector#479: + message=512-bit string: 59*00,01, 4*00 + hash=6401C4DDCDD7441581AFF57D13C1198FC2347D886D319FDA + +Set 3, vector#480: + message=512-bit string: 60*00,80, 3*00 + hash=2446A367AABBDEBA9EFD1F8CAA9805EC1A9B45200A90E2C1 + +Set 3, vector#481: + message=512-bit string: 60*00,40, 3*00 + hash=37C1C64324D78E1F7549E6169FA66D492184F3A5A524810F + +Set 3, vector#482: + message=512-bit string: 60*00,20, 3*00 + hash=91A620E120AB9C4949C6D3E27A856F079F76DA00D56C3A22 + +Set 3, vector#483: + message=512-bit string: 60*00,10, 3*00 + hash=575C19C550408D8454650AF1739812870E371BA8F34B6861 + +Set 3, vector#484: + message=512-bit string: 60*00,08, 3*00 + hash=5AB6FF5B263ACFAB2013C3068C03A82979EA6DB287A3ECDD + +Set 3, vector#485: + message=512-bit string: 60*00,04, 3*00 + hash=BB40E88E5DA7D4B12356124D9ED74BA5283C502FC68B5A1B + +Set 3, vector#486: + message=512-bit string: 60*00,02, 3*00 + hash=CFEC678B1CD75F4249D536C9399F11C12CE9938EE8CADCFF + +Set 3, vector#487: + message=512-bit string: 60*00,01, 3*00 + hash=8A26E3715E0471DD3616A9E505F4C73722BB42FB233BF641 + +Set 3, vector#488: + message=512-bit string: 61*00,80, 2*00 + hash=ED38E1AA4B73AF6024471252F8102E77ECBF4BC315DB1C31 + +Set 3, vector#489: + message=512-bit string: 61*00,40, 2*00 + hash=4D5E37A37AFC8C7DBBC25AF2C6670ED2DAFB56B5376E2550 + +Set 3, vector#490: + message=512-bit string: 61*00,20, 2*00 + hash=958603BDA98C29A87AEDB0C1C8F559D161EA4FCBE9EED392 + +Set 3, vector#491: + message=512-bit string: 61*00,10, 2*00 + hash=A7F58251627E2C4C82ED1AFADB2FFF3B3483CDC279117E1E + +Set 3, vector#492: + message=512-bit string: 61*00,08, 2*00 + hash=4B003F86DA13C24E10041F934DC02EAA9E86C4200550DE8F + +Set 3, vector#493: + message=512-bit string: 61*00,04, 2*00 + hash=6139AB107BCD192E8419E869F77738D2624BA81FD774828F + +Set 3, vector#494: + message=512-bit string: 61*00,02, 2*00 + hash=15E286064681AB50343CDFD1E178F6DAD9071E3727997DA1 + +Set 3, vector#495: + message=512-bit string: 61*00,01, 2*00 + hash=95A26E99BFFBB5D0027B380688D3E5C567454F4F2F283C41 + +Set 3, vector#496: + message=512-bit string: 62*00,80, 1*00 + hash=45326511C3070AD878172A7DA38D17ED65D17BFFB0298058 + +Set 3, vector#497: + message=512-bit string: 62*00,40, 1*00 + hash=C127E412181EF4734360466A38245409E44B2B208FFF4D67 + +Set 3, vector#498: + message=512-bit string: 62*00,20, 1*00 + hash=4C9A55B7BC50B8D7343F1FF351F13A89CA53E8AD2F056559 + +Set 3, vector#499: + message=512-bit string: 62*00,10, 1*00 + hash=9B93DF18074112C26FBEB1EA277070EF4D5A1778376DC12C + +Set 3, vector#500: + message=512-bit string: 62*00,08, 1*00 + hash=79CE5EFD59A9A0ADBC3661F278B3C540A0332A9E8FA30E07 + +Set 3, vector#501: + message=512-bit string: 62*00,04, 1*00 + hash=886F0AD49176EAF30EA422CDA7D1061AF2D62DA67C672407 + +Set 3, vector#502: + message=512-bit string: 62*00,02, 1*00 + hash=54C7674DC49D49E63DD7296241C3F2F0B022BCC0451400F0 + +Set 3, vector#503: + message=512-bit string: 62*00,01, 1*00 + hash=9DFC07C61179B9DEEA1D452D3073C2A12CB0342EC8FA25C1 + +Set 3, vector#504: + message=512-bit string: 63*00,80, 0*00 + hash=E9C6E911956A0D7C3958F4E0252A4DF98FAE33AFC834EA10 + +Set 3, vector#505: + message=512-bit string: 63*00,40, 0*00 + hash=9DB1556485B4C5C67FC532C4C6937AFA3A889FDB09B055A7 + +Set 3, vector#506: + message=512-bit string: 63*00,20, 0*00 + hash=5875A1A391DEDD84155F3805A81EF68AD288A9E77DEB4324 + +Set 3, vector#507: + message=512-bit string: 63*00,10, 0*00 + hash=5DA3FCD577895036D0AB8D6BC654C59E76C0312C81F3A374 + +Set 3, vector#508: + message=512-bit string: 63*00,08, 0*00 + hash=3DB3B9731E66FEF6039A2723C7CD7814F2A5F8ED20807361 + +Set 3, vector#509: + message=512-bit string: 63*00,04, 0*00 + hash=C784C70B8F431D8AEA3F5ADF2BA55AB4BEC9C580558CD0BD + +Set 3, vector#510: + message=512-bit string: 63*00,02, 0*00 + hash=B256AA37A7DA84F3599B338E2B853B92ECBA5FDE6901B620 + +Set 3, vector#511: + message=512-bit string: 63*00,01, 0*00 + hash=1CDEC1D10BD749090B1F491A4FC8E2F8B150D64F3215CE8F + + +Test vectors -- set 4 +===================== + +Set 4, vector# 0: + message=192 zero bits + hash=CDDDCACFEA7B70B485655BA3DC3F60DEE4F6B8F861069E33 + iterated 100000 times=35C4F594F7E827FFC68BFECEBEDA314EDC6FE917BDF00B66 + + + +End of test vectors