# String message to MD5 Hash
# Creates a MD5 hash from a message string
# Version 1.00, 6/17/2012, Created by TealFrog
# Script tested and developed under MikroTik ROS 5.14 thru 5.17
#
# This software is identified as using and is based on the, "RSA Data Security, 
# Inc. MD5 Message-Digest Algorithm".  This program is a derived work from the RSA Data
# Security, Inc. MD5 Message-Digest Algorithm.
# See http://www.ietf.org/rfc/rfc1321.txt for further information.
#
# The author of this program makes no representations concerning either
# the merchantability of this software or the suitability of this
# software for any particular purpose or non-infringement.
# This program is provided "as is" without express or implied warranty of any kind.
# The author makes no representations or warranties of any kind as to the 
# completeness, accuracy, timeliness, availability, functionality and compliance
# with applicable laws. By using this software you accept the risk that the 
# information may be incomplete or inaccurate or may not meet your needs 
# and requirements. The author shall not be liable for any damages or 
# injury arising out of the use of this program. Use this program at your own risk. 
#
# MD5 has been shown to not be collision resistant, as such MD5 is not suitable 
# for certain applications involving security and/or cryptography, 
# see http://en.wikipedia.org/wiki/Md5 for additional information.
#
# $progName, Name of script, set appropriately
:local progName "StrToMd5"

# $arrMessages, An array containing one ore more string messages to create MD5 hash from 
:local arrMessages ( "ABCDEFGHIJKLMNOPQRSTUVWZYZ",   \
                     "abcedefghijklmnopqrstuvwxyz",  \
                     "The quick brown fox jumps over the lazy dog." )

# $strPrefix, Set to a prefix to add before MD5 hash, set "" for empty
:local strPrefix "0x"

# $strSuffix, Set to a suffix to add after MD5 hash, set "" for empty
:local strSuffix ""

# Set $Debug to 1 for additional output, set to zero to turn off debug
:local Debug 0

# $strHexValues, Used to create hexadecimal output
:local strHexValues "0123456789abcdef"
# To have uppercase hexadecimal A-F use the next line instead of the above
# :local strHexValues "0123456789ABCDEF"

# No futher modification required beyond this point unless customizing script
# Start by defining constant values

# ASCII Table $CharSet[0..127]
:local arrCharSet ( "\00", "\01", "\02", "\03", "\04", "\05", "\06", "\07", \ 
                    "\08", "\09", "\0A", "\0B", "\0C", "\0D", "\0E", "\0F", \ 
                    "\10", "\11", "\12", "\13", "\14", "\15", "\16", "\17", \
                    "\18", "\19", "\1A", "\1B", "\1C", "\1D", "\1E", "\1F", \
                    "\20", "\21", "\22", "\23", "\24", "\25", "\26", "\27", \
                    "\28", "\29", "\2A", "\2B", "\2C", "\2D", "\2E", "\2F", \
                    "\30", "\31", "\32", "\33", "\34", "\35", "\36", "\37", \
                    "\38", "\39", "\3A", "\3B", "\3C", "\3D", "\3E", "\3F", \
                    "\40", "\41", "\42", "\43", "\44", "\45", "\46", "\47", \ 
                    "\48", "\49", "\4A", "\4B", "\4C", "\4D", "\4E", "\4F", \
                    "\50", "\51", "\52", "\53", "\54", "\55", "\56", "\57", \
                    "\58", "\59", "\5A", "\5B", "\5C", "\5D", "\5E", "\5F", \
                    "\60", "\61", "\62", "\63", "\64", "\65", "\66", "\67", \
                    "\68", "\69", "\6A", "\6B", "\6C", "\6D", "\6E", "\6F", \
                    "\70", "\71", "\72", "\73", "\74", "\75", "\76", "\77", \
                    "\78", "\79", "\7A", "\7B", "\7C", "\7D", "\7E", "\7F" ) 

# k[i] = floor(abs(sin(i + 1)) × 4294967296) 
# Or just use the following table $k[0..63]:
:local k ( 0xD76AA478, 0xE8C7B756, 0x242070DB, 0xC1BDCEEE, \
           0xF57C0FAF, 0x4787C62A, 0xA8304613, 0xFD469501, \
           0x698098D8, 0x8B44F7AF, 0xFFFF5BB1, 0x895CD7BE, \
           0x6B901122, 0xFD987193, 0xA679438E, 0x49B40821, \
           0xF61E2562, 0xC040B340, 0x265E5A51, 0xE9B6C7AA, \
           0xD62F105D, 0x02441453, 0xD8A1E681, 0xE7D3FBC8, \
           0x21E1CDE6, 0xC33707D6, 0xF4D50D87, 0x455A14ED, \
           0xA9E3E905, 0xFCEFA3F8, 0x676F02D9, 0x8D2A4C8A, \
           0xFFFA3942, 0x8771F681, 0x6D9D6122, 0xFDE5380C, \
           0xA4BEEA44, 0x4BDECFA9, 0xF6BB4B60, 0xBEBFBC70, \
           0x289B7EC6, 0xEAA127FA, 0xD4EF3085, 0x04881D05, \
           0xD9D4D039, 0xE6DB99E5, 0x1FA27CF8, 0xC4AC5665, \
           0xF4292244, 0x432AFF97, 0xAB9423A7, 0xFC93A039, \
           0x655B59C3, 0x8F0CCC92, 0xFFEFF47D, 0x85845DD1, \
           0x6FA87E4F, 0xFE2CE6E0, 0xA3014314, 0x4E0811A1, \
           0xF7537E82, 0xBD3AF235, 0x2AD7D2BB, 0xEB86D391 )

:local a 0x67452301 
:local b 0xEFCDAB89
:local c 0x98BADCFE
:local d 0x10325476

:local AA 0x67452301
:local BB 0xEFCDAB89
:local CC 0x98BADCFE
:local DD 0x10325476

:local s1 (  7, 12, 17, 22 )
:local s2 (  5,  9, 14, 20 )
:local s3 (  4, 11, 16, 23 )
:local s4 (  6, 10, 15, 21 )

:local i 0
:local j 0
:local x 0
:local S 0
:local T 0
:local lcv 0
:local tmp1 0

:local arrMd5State {}
:local arrWordArray {}
:local ch ""
:local iByteCount 0
:local iCharVal 3
:local iDec 0
:local iHexDigit 8
:local iMd5State 0
:local lBytePosition 0
:local lMessageLength 0
:local lNumberOfWords 0        
:local lShiftedVal 0
:local lWordArray {}
:local lWordArrLen 0
:local lWordCount 0
:local sHex ""
:local sMd5Hash ""
:local sMd5Output ""
:local strWordArray ""

# Start of main program and message loop
:put "$progName: Running..."
:foreach strMessage in=[ :toarray $arrMessages ] do={
   :put "$progName: Message: $strMessage"
   :set ch ""
   :set lShiftedVal 0
   :set lWordCount 0
   :set iByteCount 0
   :set iCharVal 3
   :set lBytePosition 0
   :set lMessageLength [ :len $strMessage ]
   :set lNumberOfWords ( ( ( ( $lMessageLength + 8 ) / 64 ) + 1 ) * 16 )        
   :set strWordArray ""
   :set arrWordArray {}

# Convert to word array 
   :for i from=1 to=($lNumberOfWords) do={
      :set strWordArray ("0," . $strWordArray)
   }
   :set strWordArray  [ :pick $strWordArray 0 ( [ :len $strWordArray ] - 1 ) ]
   :set arrWordArray [ :toarray $strWordArray ]
   
   :if ( $Debug > 0 ) do={
      :put ("$progName: Message Length: " . $lMessageLength)
      :put ("$progName: Number of Words: " . $lNumberOfWords)
   }
   :while ($iByteCount < $lMessageLength) do={
      :set lWordCount ($iByteCount / 4)
      :set lBytePosition (($iByteCount % 4) * 8)
         :if (($lBytePosition < 0) or ($lBytePosition > 31)) do={
            :error ( "$progName: Error --  Calculating byte position " . \
			       "# $lBytePosition, must be 0 thru 31." )
         }
         :set ch [ :pick $strMessage $iByteCount ]
         :if ( [ :len [ :find $arrCharSet $ch ] ] > 0 ) do={
            :set iCharVal ([ :tonum [ :find $arrCharSet $ch ] ])
         } else={
            :error "$progName: Error -- Input contains undefined ASCII value."
         }
         :if ( $Debug > 0 ) do={
            :put ( "$progName: parsed character \$ch: '$ch' " . \
			     "ASCII value \$iCharVal: $iCharVal" )
         }
         :set lShiftedVal ((($iCharVal) << ($lBytePosition)) | \
		                   (($iCharVal) >> (32-($lBytePosition))))
         :if ($iByteCount = 0) do={
            :set lShiftedVal (([ :tonum $lShiftedVal ] + 0) & 0xFFFFFFFF)
            :set arrWordArray (([ :tonum $lShiftedVal ]), \
			                    [ :pick $arrWordArray 1 [ :len $arrWordArray] ])
         } else={
            :set lShiftedVal (([ :tonum [ :pick $arrWordArray $lWordCount] ] + 0) | \
			                  ([ :tonum $lShiftedVal ] + 0))
            :set lShiftedVal (([ :tonum $lShiftedVal ] + 0) & 0xFFFFFFFF)
            :set arrWordArray  ([ :pick $arrWordArray 0 $lWordCount ], $lShiftedVal, \
               [ :pick $arrWordArray ([ :tonum $lWordCount ] + 1) [ :len $arrWordArray] ])   
         }
         :set iByteCount ( $iByteCount + 1 )
      }
      :set lWordCount ( $iByteCount / 4 )
      :set lBytePosition ( ( $iByteCount % 4 ) * 8 )
      :set lShiftedVal [ :pick $arrWordArray $lWordCount ]
      
      :set lShiftedVal ( ( [ :tonum [ :pick $arrWordArray $lWordCount ] ] + 0 ) | \
                         ( ( 0x80 << $lBytePosition ) | \
				           ( 0x80 >> ( 32 - $lBytePosition ) ) ) ) 
      
      :set arrWordArray  ( ( [ :pick $arrWordArray 0 $lWordCount ]  ),  \
                             [ :tonum $lShiftedVal ], \
                           ( [ :pick $arrWordArray ( [ :tonum $lWordCount ] + 1 ) \
   					    [ :len $arrWordArray ] ] ) ) 
					       
      :set arrWordArray  [ :toarray ( ( [ :pick $arrWordArray 0 ($lNumberOfWords - 2) ] ), \
                                    ( ( ( [ :tonum $lMessageLength ] + 0 ) << 3 ) | \
   							     ( ( [ :tonum $lMessageLength ] + 0 ) >> 29 ) ), \
							        ( ( [ :tonum $lMessageLength ] + 0 )  >> 29 ) ) ]
      :set lWordArray [ :toarray $arrWordArray ]
      :set lWordArrLen ( ( [ :len $lWordArray ] ) - 1 )

### Main Loop ###
      :set tmp1 0
      :set x 0
      :set T 0
      :set S 0
      :set i 0
      :set j 0
      :for lcv from=0 to=( $lWordArrLen ) step=16 do={
         :set a 0x67452301 
         :set b 0xEFCDAB89
         :set c 0x98BADCFE
         :set d 0x10325476
         :set AA [ :tonum $a ]
         :set BB [ :tonum $b ]
         :set CC [ :tonum $c ]
         :set DD [ :tonum $d ]

### Round 1 ### 
         :for i from=0 to=15 do={
            :set x ( [ :tonum [ :pick $lWordArray ( $i & 15 ) ] ] + 0 )
            :set T ( [ :tonum [ :pick $k $i ] ] + 0 )
            :set S ( [ :tonum [ :pick $s1 ( $i & 3 ) ] ] + 0 )
# Next line is an alternate mmethod, instead of the line after it	  
#         :set tmp1 ( ( (($b & $c) | (((($b + 1) * -1)) & $d)) + $a + $T + $x ) & 0xFFFFFFFF )
            :set tmp1 ( ( ( $d ^ ( $b & ( $c ^ $d ) ) ) + $a + $T + $x ) & 0xFFFFFFFF )
            :set tmp1 (((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF)
            :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
            :if ( $Debug > 0 ) do={			
               :put ("$progName: Round 1, Answer \$tmp1: $tmp1") 
            }			   
# Rotate a,b,c,d params positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a 
# and a gets new value from tmp1
            :set a ( ( [ :tonum $d ] + 0 ) & 0xFFFFFFFF )
            :set d ( ( [ :tonum $c ] + 0 ) & 0xFFFFFFFF )
            :set c ( ( [ :tonum $b ] + 0 ) & 0xFFFFFFFF )
            :set b ( ( [ :tonum $tmp1 ] + 0 ) & 0xFFFFFFFF )
         }
      
### Round 2 ###
         :set j 1
         :for i from=0 to=15 do={
            :set x ( [ :tonum [ :pick $lWordArray ( ( [ :tonum $j ] + 0 ) & 15 ) ] ] + 0 )
            :set T ( [ :tonum [ :pick $k ( $i + 16 ) ] ] + 0 )
            :set S ( [ :tonum [ :pick $s2 ( $i & 3 ) ] ] + 0 )
            :set tmp1 ( ( ( $c ^ ( $d & ( $b ^ $c ) ) ) + $a + $T + $x ) & 0xFFFFFFFF )
            :set tmp1 (((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF)
            :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
            :if ( $Debug > 0 ) do={			
               :put ("$progName: Round 2, Answer \$tmp1: $tmp1") 
            }			   
# Rotate a,b,c,d param positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a
            :set a ( ( [ :tonum $d ] + 0 ) & 0xFFFFFFFF )
            :set d ( ( [ :tonum $c ] + 0 ) & 0xFFFFFFFF )
            :set c ( ( [ :tonum $b ] + 0 ) & 0xFFFFFFFF )
            :set b ( ( [ :tonum $tmp1 ] + 0 ) & 0xFFFFFFFF )
            :set j ( $j + 5 )
         }
         
### Round 3 ###
         :set j 5
         :for i from=0 to=15 do={
            :set x ( [ :tonum [ :pick $lWordArray ( ( [ :tonum $j ] + 0 ) & 15 ) ] ] + 0 )
            :set T ( [ :tonum [ :pick $k ( $i + 32 ) ] ] + 0 )
            :set S ( [ :tonum [ :pick $s3 ( $i & 3 ) ] ] + 0 )
            :set tmp1 ( ( ( $b ^ $c ^ $d ) + $a + $T + $x ) & 0xFFFFFFFF )
            :set tmp1 (((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF)
            :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
            :if ( $Debug > 0 ) do={			
               :put ("$progName: Round 3, Answer \$tmp1: $tmp1") 
            }			   
# Rotate a,b,c,d param positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a
            :set a ( ( [ :tonum $d ] + 0) & 0xFFFFFFFF )
            :set d ( ( [ :tonum $c ] + 0) & 0xFFFFFFFF )
            :set c ( ( [ :tonum $b ] + 0) & 0xFFFFFFFF )
            :set b ( ( [ :tonum $tmp1 ] + 0) & 0xFFFFFFFF )
            :set j ( $j + 3 )
         }
         
### Round 4 ###
         :set j 0
         :for i from=0 to=15 do={
            :set x ( [ :tonum [ :pick $lWordArray ( ( [ :tonum $j ] + 0 ) & 15 ) ] ] + 0 )
            :set T ( [ :tonum [ :pick $k ( $i + 48 ) ] ] + 0 )
            :set S ( [ :tonum [ :pick $s4 ( $i & 3 ) ] ] + 0 )
# Next line is alternate method to the line following	  
#         :set tmp1 ( $c ^ ( $b | ( ( $d & 0xFFFFFFFF ) ^ 0xFFFFFFFF ) ) )
            :set tmp1 ( ( $c ^ ( $b | ( -1 * ( $d + 1 ) ) ) ) & 0xFFFFFFFF )
            :set tmp1 ( ( $tmp1 + $a + $T + $x ) & 0xFFFFFFFF )
            :set tmp1 ( ((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF )
            :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
            :if ( $Debug > 0 ) do={			
               :put ("$progName: Round 4, Answer \$tmp1: $tmp1") 
            }			   
# Rotate a,b,c,d param positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a
            :set a ( ( [ :tonum $d ] + 0) & 0xFFFFFFFF )
            :set d ( ( [ :tonum $c ] + 0) & 0xFFFFFFFF )
            :set c ( ( [ :tonum $b ] + 0) & 0xFFFFFFFF )
            :set b ( ( [ :tonum $tmp1 ] + 0) & 0xFFFFFFFF )
            :set j ( $j + 7 )
         }      
         :set a ( ( $a + $AA ) & 0xFFFFFFFF )    
         :set b ( ( $b + $BB ) & 0xFFFFFFFF )    
         :set c ( ( $c + $CC ) & 0xFFFFFFFF )    
         :set d ( ( $d + $DD ) & 0xFFFFFFFF )    
      }
      :set arrMd5State [ :toarray "$a, $b, $c, $d" ]
      :set sMd5Hash ""
      :set sMd5Output ""
      :set iDec 0
      :set iMd5State 0
      :set sHex ""
      :for i from=0 to=3 do={
         :set iMd5State [ :pick $arrMd5State $i ] 	  
         :for j from=0 to=3 do={
	        :set iMd5State ( [ :tonum $iMd5State ] & 0xFFFFFFFF )
            :if ( $j < 1 ) do={
               :set iDec ( [ :tonum $iMd5State ] & 255 )
            } else={
		       :set iDec ( ( $iMd5State & 0x7FFFFFFE ) / ( 2 << ( ( $j * 8 ) - 1 ) ) )
   		    :if ( ( $iMd5State & 0x80000000 ) > 0 ) do={
	              :set iDec ( $iDec | ( 0x40000000 /  ( 2 << ( ( $j * 8 ) - 2 ) ) ) )
 	           }
   		       :set iDec ( $iDec & 0xFF ) 
            }
   	        :set sHex ""
            :for k from=0 to=( 4 * ( $iHexDigit - 1 ) ) step=4 do={
               :set sHex ( [ :pick [ :tostr $strHexValues ] \
			             ( ( $iDec >> $k ) & 0xF ) \ 
						 ( ( ( $iDec >> $k ) & 0xF ) + 1 ) ] . $sHex ) 
            }
   	        :set sHex [ :tostr $sHex ]
	        :set sHex [ :pick $sHex ( [ :len $sHex ] - 2 ) [ :len $sHex ] ]
            :set sMd5Output ( $sMd5Output . $sHex )	  
         }
   }
# Modify next line to customize MD5 output string	  
   :put ( [ :tostr $strPrefix ] . [ :tostr $sMd5Output ] . [ :tostr $strSuffix ] )
}
:put "$progName: Done."

:local arrMd5State {}

:local arrMd5State []

# String message to MD5 Hash
# Creates a MD5 hash from a message string
# Version 1.00, 6/17/2012, Created by TealFrog
# Version 1.1 2/11/2016, Modified by FAMS
# Script tested and developed under MikroTik ROS 6.3 to 6.33
# 
#
# This software is identified as using and is based on the, "RSA Data Security, 
# Inc. MD5 Message-Digest Algorithm".  This program is a derived work from the RSA Data
# Security, Inc. MD5 Message-Digest Algorithm.
# See http://www.ietf.org/rfc/rfc1321.txt for further information.
#
# The author of this program makes no representations concerning either
# the merchantability of this software or the suitability of this
# software for any particular purpose or non-infringement.
# This program is provided "as is" without express or implied warranty of any kind.
# The author makes no representations or warranties of any kind as to the 
# completeness, accuracy, timeliness, availability, functionality and compliance
# with applicable laws. By using this software you accept the risk that the 
# information may be incomplete or inaccurate or may not meet your needs 
# and requirements. The author shall not be liable for any damages or 
# injury arising out of the use of this program. Use this program at your own risk. 
#
# MD5 has been shown to not be collision resistant, as such MD5 is not suitable 
# for certain applications involving security and/or cryptography, 
# see http://en.wikipedia.org/wiki/Md5 for additional information.
#
# $progName, Name of script, set appropriately
:global StrToMd5 do={

  :local progName "StrToMd5"
  :local strMessage $1
  # $strPrefix, Set to a prefix to add before MD5 hash, set "" for empty
  :local strPrefix ""

  # $strSuffix, Set to a suffix to add after MD5 hash, set "" for empty
  :local strSuffix ""
       # Set $Debug to 1 for additional output, set to zero to turn off debug
  :local Debug $2

  # $strHexValues, Used to create hexadecimal output
  :local strHexValues "0123456789abcdef"
  # To have uppercase hexadecimal A-F use the next line instead of the above
  # :local strHexValues "0123456789ABCDEF"

  # No futher modification required beyond this point unless customizing script
  # Start by defining constant values

  # ASCII Table $CharSet[0..127]
  :local arrCharSet ( "\00", "\01", "\02", "\03", "\04", "\05", "\06", "\07", \ 
                     "\08", "\09", "\0A", "\0B", "\0C", "\0D", "\0E", "\0F", \ 
                     "\10", "\11", "\12", "\13", "\14", "\15", "\16", "\17", \
                     "\18", "\19", "\1A", "\1B", "\1C", "\1D", "\1E", "\1F", \
                     "\20", "\21", "\22", "\23", "\24", "\25", "\26", "\27", \
                     "\28", "\29", "\2A", "\2B", "\2C", "\2D", "\2E", "\2F", \
                     "\30", "\31", "\32", "\33", "\34", "\35", "\36", "\37", \
                     "\38", "\39", "\3A", "\3B", "\3C", "\3D", "\3E", "\3F", \
                     "\40", "\41", "\42", "\43", "\44", "\45", "\46", "\47", \ 
                     "\48", "\49", "\4A", "\4B", "\4C", "\4D", "\4E", "\4F", \
                     "\50", "\51", "\52", "\53", "\54", "\55", "\56", "\57", \
                     "\58", "\59", "\5A", "\5B", "\5C", "\5D", "\5E", "\5F", \
                     "\60", "\61", "\62", "\63", "\64", "\65", "\66", "\67", \
                     "\68", "\69", "\6A", "\6B", "\6C", "\6D", "\6E", "\6F", \
                     "\70", "\71", "\72", "\73", "\74", "\75", "\76", "\77", \
                     "\78", "\79", "\7A", "\7B", "\7C", "\7D", "\7E", "\7F" ) 

  # k[i] = floor(abs(sin(i + 1))  4294967296) 
  # Or just use the following table $k[0..63]:
  :local k ( 0xD76AA478, 0xE8C7B756, 0x242070DB, 0xC1BDCEEE, \
            0xF57C0FAF, 0x4787C62A, 0xA8304613, 0xFD469501, \
            0x698098D8, 0x8B44F7AF, 0xFFFF5BB1, 0x895CD7BE, \
            0x6B901122, 0xFD987193, 0xA679438E, 0x49B40821, \
            0xF61E2562, 0xC040B340, 0x265E5A51, 0xE9B6C7AA, \
            0xD62F105D, 0x02441453, 0xD8A1E681, 0xE7D3FBC8, \
            0x21E1CDE6, 0xC33707D6, 0xF4D50D87, 0x455A14ED, \
            0xA9E3E905, 0xFCEFA3F8, 0x676F02D9, 0x8D2A4C8A, \
            0xFFFA3942, 0x8771F681, 0x6D9D6122, 0xFDE5380C, \
            0xA4BEEA44, 0x4BDECFA9, 0xF6BB4B60, 0xBEBFBC70, \
            0x289B7EC6, 0xEAA127FA, 0xD4EF3085, 0x04881D05, \
            0xD9D4D039, 0xE6DB99E5, 0x1FA27CF8, 0xC4AC5665, \
            0xF4292244, 0x432AFF97, 0xAB9423A7, 0xFC93A039, \
            0x655B59C3, 0x8F0CCC92, 0xFFEFF47D, 0x85845DD1, \
            0x6FA87E4F, 0xFE2CE6E0, 0xA3014314, 0x4E0811A1, \
            0xF7537E82, 0xBD3AF235, 0x2AD7D2BB, 0xEB86D391 )

  :local a 0x67452301 
  :local b 0xEFCDAB89
  :local c 0x98BADCFE
  :local d 0x10325476

  :local AA 0x67452301
  :local BB 0xEFCDAB89
  :local CC 0x98BADCFE
  :local DD 0x10325476

  :local s1 (  7, 12, 17, 22 )
  :local s2 (  5,  9, 14, 20 )
  :local s3 (  4, 11, 16, 23 )
  :local s4 (  6, 10, 15, 21 )

  :local i 0
  :local j 0
  :local x 0
  :local S 0
  :local T 0
  :local lcv 0
  :local tmp1 0

  :local arrMd5State []
  :local arrWordArray []
  :local ch ""
  :local iByteCount 0
  :local iCharVal 3
  :local iDec 0
  :local iHexDigit 8
  :local iMd5State 0
  :local lBytePosition 0
  :local lMessageLength 0
  :local lNumberOfWords 0        
  :local lShiftedVal 0
  :local lWordArray []
  :local lWordArrLen 0
  :local lWordCount 0
  :local sHex ""
  :local sMd5Hash ""
  :local sMd5Output ""
  :local strWordArray ""

  # Start of main program and message loop
  if ( $Debug > 0 ) do={
    :put "$progName: Running..."
    :put "$progName: Message: $strMessage"
  }
  :set ch ""
  :set lShiftedVal 0
  :set lWordCount 0
  :set iByteCount 0
  :set iCharVal 3
  :set lBytePosition 0
  :set lMessageLength [ :len $strMessage ]
  :set lNumberOfWords ( ( ( ( $lMessageLength + 8 ) / 64 ) + 1 ) * 16 )        
  :set strWordArray ""
  :set arrWordArray []

  # Convert to word array 
  :for i from=1 to=($lNumberOfWords) do={
    :set strWordArray ("0," . $strWordArray)
  }
  :set strWordArray  [ :pick $strWordArray 0 ( [ :len $strWordArray ] - 1 ) ]
  :set arrWordArray [ :toarray $strWordArray ]
  :if ( $Debug > 0 ) do={
    :put ("$progName: Message Length: " . $lMessageLength)
    :put ("$progName: Number of Words: " . $lNumberOfWords)
    :put ("$progName: strWordArray $strWordArray")
  }
  :while ($iByteCount < $lMessageLength) do={
    :set lWordCount ($iByteCount / 4)
    :set lBytePosition (($iByteCount % 4) * 8)
    :if (($lBytePosition < 0) or ($lBytePosition > 31)) do={
      :error ( "$progName: Error --  Calculating byte position " . \
          "# $lBytePosition, must be 0 thru 31." )
    }
    :set ch [ :pick $strMessage $iByteCount ]
    :if ( [ :len [ :find $arrCharSet $ch ] ] > 0 ) do={
      :set iCharVal ([ :tonum [ :find $arrCharSet $ch ] ])
    } else={
      :error "$progName: Error -- Input contains undefined ASCII value."
    }
    :if ( $Debug > 0 ) do={
      :put ( "$progName: parsed character \$ch: '$ch' " . \
        "ASCII value \$iCharVal: $iCharVal" )
    }
    :set lShiftedVal ((($iCharVal) << ($lBytePosition)) | \
                   (($iCharVal) >> (32-($lBytePosition))))
    :if ($iByteCount = 0) do={
      :set lShiftedVal (([ :tonum $lShiftedVal ] + 0) & 0xFFFFFFFF)
      :set arrWordArray (([ :tonum $lShiftedVal ]), \
                       [ :pick $arrWordArray 1 [ :len $arrWordArray] ])
    } else={
      :set lShiftedVal (([ :tonum [ :pick $arrWordArray $lWordCount] ] + 0) | \
                     ([ :tonum $lShiftedVal ] + 0))
      :set lShiftedVal (([ :tonum $lShiftedVal ] + 0) & 0xFFFFFFFF)
      :set arrWordArray  ([ :pick $arrWordArray 0 $lWordCount ], $lShiftedVal, \
         [ :pick $arrWordArray ([ :tonum $lWordCount ] + 1) [ :len $arrWordArray] ])   
    }
    :set iByteCount ( $iByteCount + 1 )
  }
  :set lWordCount ( $iByteCount / 4 )
  :set lBytePosition ( ( $iByteCount % 4 ) * 8 )
  :set lShiftedVal [ :pick $arrWordArray $lWordCount ]

  :set lShiftedVal ( ( [ :tonum [ :pick $arrWordArray $lWordCount ] ] + 0 ) | \
                   ( ( 0x80 << $lBytePosition ) | \
                 ( 0x80 >> ( 32 - $lBytePosition ) ) ) ) 

  :set arrWordArray  ( ( [ :pick $arrWordArray 0 $lWordCount ]  ),  \
                       [ :tonum $lShiftedVal ], \
                     ( [ :pick $arrWordArray ( [ :tonum $lWordCount ] + 1 ) \
                [ :len $arrWordArray ] ] ) ) 
                
  :set arrWordArray  [ :toarray ( ( [ :pick $arrWordArray 0 ($lNumberOfWords - 2) ] ), \
                              ( ( ( [ :tonum $lMessageLength ] + 0 ) << 3 ) | \
                       ( ( [ :tonum $lMessageLength ] + 0 ) >> 29 ) ), \
                       ( ( [ :tonum $lMessageLength ] + 0 )  >> 29 ) ) ] 
  :set lWordArray [ :toarray $arrWordArray ]
  :set lWordArrLen ( ( [ :len $lWordArray ] ) - 1 )
  :if ($Debug >0 ) do={
    :put "lWordArrLen $lWordArrLen"
  }
  ### Main Loop ###
  :set tmp1 0
  :set x 0
  :set T 0
  :set S 0
  :set i 0
  :set j 0
  :local iteration 0
  #:set a 0x67452301 
  #:set b 0xEFCDAB89
  #:set c 0x98BADCFE
  #:set d 0x10325476
  #Loop Principal
  :if ( $Debug >0 ) do={
    :put $lWordArray
  }
  :for lcv from=0 to=( $lWordArrLen ) step=16 do={
    :set AA [ :tonum $a ]
    :set BB [ :tonum $b ]
    :set CC [ :tonum $c ]
    :set DD [ :tonum $d ]
    :if ( $Debug > 0 ) do={
      :put $iteration
    }
    :local chuckoffset ($iteration * 16)
  ### Round 1 ### 
    :for i from=0 to=15 do={
      :set x ( [ :tonum [ :pick $lWordArray (( $i & 15 ) + $chuckoffset) ] ] + 0 )
      :set T ( [ :tonum [ :pick $k $i ] ] + 0 )
      :set S ( [ :tonum [ :pick $s1 ( $i & 3 ) ] ] + 0 )
  # Next line is an alternate mmethod, instead of the line after it     
  #         :set tmp1 ( ( (($b & $c) | (((($b + 1) * -1)) & $d)) + $a + $T + $x ) & 0xFFFFFFFF )
      :set tmp1 ( ( ( $d ^ ( $b & ( $c ^ $d ) ) ) + $a + $T + $x ) & 0xFFFFFFFF )
      :set tmp1 (((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF)
      :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
      :if ( $Debug > 0 ) do={         
         :put ("$progName: Round 1, Answer \$tmp1: $tmp1") 
      }            
  # Rotate a,b,c,d params positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a 
  # and a gets new value from tmp1
      :set a ( ( [ :tonum $d ] + 0 ) & 0xFFFFFFFF )
      :set d ( ( [ :tonum $c ] + 0 ) & 0xFFFFFFFF )
      :set c ( ( [ :tonum $b ] + 0 ) & 0xFFFFFFFF )
      :set b ( ( [ :tonum $tmp1 ] + 0 ) & 0xFFFFFFFF )
    }

  ### Round 2 ###
    :set j 1
    :for i from=0 to=15 do={
      :set x ( [ :tonum [ :pick $lWordArray (( ( [ :tonum $j ] + 0 ) & 15 ) + $chuckoffset ) ] ] + 0 )
      :set T ( [ :tonum [ :pick $k ( $i + 16 ) ] ] + 0 )
      :set S ( [ :tonum [ :pick $s2 ( $i & 3 ) ] ] + 0 )
      :set tmp1 ( ( ( $c ^ ( $d & ( $b ^ $c ) ) ) + $a + $T + $x ) & 0xFFFFFFFF )
      :set tmp1 (((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF)
      :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
      :if ( $Debug > 0 ) do={         
         :put ("$progName: Round 2, Answer \$tmp1: $tmp1") 
      }
  # Rotate a,b,c,d param positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a
      :set a ( ( [ :tonum $d ] + 0 ) & 0xFFFFFFFF )
      :set d ( ( [ :tonum $c ] + 0 ) & 0xFFFFFFFF )
      :set c ( ( [ :tonum $b ] + 0 ) & 0xFFFFFFFF )
      :set b ( ( [ :tonum $tmp1 ] + 0 ) & 0xFFFFFFFF )
      :set j ( $j + 5 )
    }
   
  ### Round 3 ###
    :set j 5
    :for i from=0 to=15 do={
      :set x ( [ :tonum [ :pick $lWordArray ( ( ( [ :tonum $j ] + 0 ) & 15 ) + $chuckoffset) ] ] + 0 )
      :set T ( [ :tonum [ :pick $k ( $i + 32 ) ] ] + 0 )
      :set S ( [ :tonum [ :pick $s3 ( $i & 3 ) ] ] + 0 )
      :set tmp1 ( ( ( $b ^ $c ^ $d ) + $a + $T + $x ) & 0xFFFFFFFF )
      :set tmp1 (((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF)
      :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
      :if ( $Debug > 0 ) do={         
         :put ("$progName: Round 3, Answer \$tmp1: $tmp1") 
      }            
  # Rotate a,b,c,d param positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a
      :set a ( ( [ :tonum $d ] + 0) & 0xFFFFFFFF )
      :set d ( ( [ :tonum $c ] + 0) & 0xFFFFFFFF )
      :set c ( ( [ :tonum $b ] + 0) & 0xFFFFFFFF )
      :set b ( ( [ :tonum $tmp1 ] + 0) & 0xFFFFFFFF )
      :set j ( $j + 3 )
    }
   
  ### Round 4 ###
    :set j 0
    :for i from=0 to=15 do={
      :set x ( [ :tonum [ :pick $lWordArray  ( ( ( [ :tonum $j ] + 0 ) & 15 ) + $chuckoffset ) ] ] + 0 )
      :set T ( [ :tonum [ :pick $k ( $i + 48 ) ] ] + 0 )
      :set S ( [ :tonum [ :pick $s4 ( $i & 3 ) ] ] + 0 )
  # Next line is alternate method to the line following     
  #         :set tmp1 ( $c ^ ( $b | ( ( $d & 0xFFFFFFFF ) ^ 0xFFFFFFFF ) ) )
      :set tmp1 ( ( $c ^ ( $b | ( -1 * ( $d + 1 ) ) ) ) & 0xFFFFFFFF )
      :set tmp1 ( ( $tmp1 + $a + $T + $x ) & 0xFFFFFFFF )
      :set tmp1 ( ((tmp1 << $S ) | (($tmp1 >> (32 - $S)))) & 0xFFFFFFFF )
      :set tmp1 ( ( $tmp1 + $b ) & 0xFFFFFFFF )
      :if ( $Debug > 0 ) do={         
         :put ("$progName: Round 4, Answer \$tmp1: $tmp1") 
      }            
  # Rotate a,b,c,d param positions, e.g. d, a, b, c ... c, d, a, b ... b, c, d, a
      :set a ( ( [ :tonum $d ] + 0) & 0xFFFFFFFF )
      :set d ( ( [ :tonum $c ] + 0) & 0xFFFFFFFF )
      :set c ( ( [ :tonum $b ] + 0) & 0xFFFFFFFF )
      :set b ( ( [ :tonum $tmp1 ] + 0) & 0xFFFFFFFF )
      :set j ( $j + 7 )
    }
    :if ( $Debug > 0 ) do={      
      :put "Iteration $iteration = $a | $b | $c | $d"
    }
    :set a ( ( $a + $AA ) & 0xFFFFFFFF )    
    :set b ( ( $b + $BB ) & 0xFFFFFFFF )    
    :set c ( ( $c + $CC ) & 0xFFFFFFFF )    
    :set d ( ( $d + $DD ) & 0xFFFFFFFF ) 
    :set iteration ( $iteration +1 ) 
  }

  :set arrMd5State [ :toarray "$a, $b, $c, $d" ]
  :set sMd5Hash ""
  :set sMd5Output ""
  :set iDec 0
  :set iMd5State 0
  :set sHex ""
  :for i from=0 to=3 do={
    :set iMd5State [ :pick $arrMd5State $i ]      
    :for j from=0 to=3 do={
      :set iMd5State ( [ :tonum $iMd5State ] & 0xFFFFFFFF )
      :if ( $j < 1 ) do={
         :set iDec ( [ :tonum $iMd5State ] & 255 )
      } else={
        :set iDec ( ( $iMd5State & 0x7FFFFFFE ) / ( 2 << ( ( $j * 8 ) - 1 ) ) )
        :if ( ( $iMd5State & 0x80000000 ) > 0 ) do={
          :set iDec ( $iDec | ( 0x40000000 /  ( 2 << ( ( $j * 8 ) - 2 ) ) ) )
        }
        :set iDec ( $iDec & 0xFF ) 
      } 
      :set sHex ""
      :for k from=0 to=( 4 * ( $iHexDigit - 1 ) ) step=4 do={
        :set sHex ( [ :pick [ :tostr $strHexValues ] \
        ( ( $iDec >> $k ) & 0xF ) \ 
        ( ( ( $iDec >> $k ) & 0xF ) + 1 ) ] . $sHex ) 
      }
      :set sHex [ :tostr $sHex ]
      :set sHex [ :pick $sHex ( [ :len $sHex ] - 2 ) [ :len $sHex ] ]
      :set sMd5Output ( $sMd5Output . $sHex )     
    }
  }
  # Modify next line to customize MD5 output string     
  :put [( [ :tostr $strPrefix ] . [ :tostr $sMd5Output ] . [ :tostr $strSuffix ] )]
  if ( $Debug > 0 ) do={
    :put "$progName: Done."
  }
}

/import flash/MTM/Facts.rsc;
:global MtmFacts;

:local md5Tool [($MtmFacts->"execute") nsStr="getTools()->getHashing()->getMD5()"];
:put ([($md5Tool->"hash") "my string data"]); ## outputs: "8240143bd807e5a52b1f9d7dd5e21ef3"

:local str "Hello World!"
:local method "SHA1"
:local hash ([:deserialize ([/tool/fetch url="https://api.hashify.net/hash/$method/hex?value=$str" output=user as-value]->"data") from=json]->"Digest")
:put $hash

:global str2sha1 do={
	:local Debug 0

	:local strMessage [:tostr "$1"]
	
	:local arrCharSet ( "\00", "\01", "\02", "\03", "\04", "\05", "\06", "\07", \
						"\08", "\09", "\0A", "\0B", "\0C", "\0D", "\0E", "\0F", \
						"\10", "\11", "\12", "\13", "\14", "\15", "\16", "\17", \
						"\18", "\19", "\1A", "\1B", "\1C", "\1D", "\1E", "\1F", \
						"\20", "\21", "\22", "\23", "\24", "\25", "\26", "\27", \
						"\28", "\29", "\2A", "\2B", "\2C", "\2D", "\2E", "\2F", \
						"\30", "\31", "\32", "\33", "\34", "\35", "\36", "\37", \
						"\38", "\39", "\3A", "\3B", "\3C", "\3D", "\3E", "\3F", \
						"\40", "\41", "\42", "\43", "\44", "\45", "\46", "\47", \
						"\48", "\49", "\4A", "\4B", "\4C", "\4D", "\4E", "\4F", \
						"\50", "\51", "\52", "\53", "\54", "\55", "\56", "\57", \
						"\58", "\59", "\5A", "\5B", "\5C", "\5D", "\5E", "\5F", \
						"\60", "\61", "\62", "\63", "\64", "\65", "\66", "\67", \
						"\68", "\69", "\6A", "\6B", "\6C", "\6D", "\6E", "\6F", \
						"\70", "\71", "\72", "\73", "\74", "\75", "\76", "\77", \
						"\78", "\79", "\7A", "\7B", "\7C", "\7D", "\7E", "\7F"  )
						
	:local hexSymbSet "0123456789abcdef"

	:local h1   0x67452301
	:local h2   0xEFCDAB89
	:local h3   0x98BADCFE
	:local h4   0x10325476
	:local h5   0xC3D2E1F0
	:local k1   0x5A827999
	:local k2   0x6ED9EBA1
	:local k3   0x8F1BBCDC
	:local k4   0xCA62C1D6

	:local x40  0x40000000
	:local xF   0xF
	:local x100 0x100000000
	:local x7F  0x7FFFFFFF
	
	:local amp  0xFFFFFFFF
	
	:if ($Debug > 0) do={
		:put "Message: $strMessage"
	}
	
	:local messageLength [:len $strMessage]  
	
	:local binaryString ""
	:local binaryWOSpaces ""
	
	:local leftrotate 0
	:local left 0
	:local right 0
	
	:local start 0
	:local number 0
	
	:local b16 0
	:local b15 0
	:local b14 0
	:local b13 0
	:local b12 0
	:local b11 0
	:local b10 0
	:local b9  0
	:local b8  0
	:local b7  0
	:local b6  0
	:local b5  0
	:local b4  0
	:local b3  0
	:local b2  0
	:local b1  0
   
	:for i from 1 to=($messageLength) do={
		:set start (i - 1)
		:local char [:pick $strMessage $start $i]
		
		:set number [:find $arrCharSet $char]
		:set b8 0 ; :if ($number & 128) do={:set b8 1}
		:set b7 0 ; :if ($number &  64) do={:set b7 1}
		:set b6 0 ; :if ($number &  32) do={:set b6 1}
		:set b5 0 ; :if ($number &  16) do={:set b5 1}
		:set b4 0 ; :if ($number &   8) do={:set b4 1}
		:set b3 0 ; :if ($number &   4) do={:set b3 1}
		:set b2 0 ; :if ($number &   2) do={:set b2 1}
		:set b1 0 ; :if ($number &   1) do={:set b1 1}
		
		:local binaryChar "$b8$b7$b6$b5$b4$b3$b2$b1"
		
		:set binaryString "$binaryString $binaryChar"
		:set binaryWOSpaces "$binaryWOSpaces$binaryChar"
	}
	
	:local binaryLength [:len $binaryString]  
	
	:local binaryMessageLength ($messageLength * 8 - 8)
	:local bitLength ($binaryMessageLength + 8)
	
	:set number $bitLength
	:set b16 0 ; :if ($number & 32768) do={:set b16 1}
	:set b15 0 ; :if ($number & 16384) do={:set b15 1}
	:set b14 0 ; :if ($number &  8192) do={:set b14 1}
	:set b13 0 ; :if ($number &  4096) do={:set b13 1}
	:set b12 0 ; :if ($number &  2048) do={:set b12 1}
	:set b11 0 ; :if ($number &  1024) do={:set b11 1}
	:set b10 0 ; :if ($number &   512) do={:set b10 1}
	:set b9  0 ; :if ($number &   256) do={:set b9  1}
	:set b8  0 ; :if ($number &   128) do={:set b8  1}
	:set b7  0 ; :if ($number &    64) do={:set b7  1}
	:set b6  0 ; :if ($number &    32) do={:set b6  1}
	:set b5  0 ; :if ($number &    16) do={:set b5  1}
	:set b4  0 ; :if ($number &     8) do={:set b4  1}
	:set b3  0 ; :if ($number &     4) do={:set b3  1}
	:set b2  0 ; :if ($number &     2) do={:set b2  1}
	:set b1  0 ; :if ($number &     1) do={:set b1  1}
		
	:local endBitLength "$b16$b15$b14$b13$b12$b11$b10$b9$b8$b7$b6$b5$b4$b3$b2$b1"
	
	:for i from 1 to=(48) do={
		:set endBitLength "0$endBitLength"
	}
	
	:local subMod [:len $endBitLength]  
	
	:local binaryZeros ($binaryMessageLength % 512)
	
	:if ((432 - $binaryZeros) < 0) do={
		:local x (512 - $binaryZeros)
		:set binaryZeros ($x + 440 + $binaryZeros + 64)
	} else={
		:set binaryZeros (432 - $binaryZeros)
	}
	
	:local messageBinary ($binaryWOSpaces . "10000000")
	
	:while ($binaryZeros > 0) do={
		:set messageBinary ($messageBinary . "0")
		:set binaryZeros ($binaryZeros - 1)
	}
	
	:set messageBinary ($messageBinary . $endBitLength)
	
	:local mLength [:len $messageBinary]
	
	:local mArray []
	
	:local dec 0
	
	:for i from=0 to=($mLength - 1) step=32 do={
		:local subStr [:pick $messageBinary ($i + 1) ($i + 32)]
		
		:set dec 0
		
		:local subStrLen [:len $subStr]
		
		:for j from 1 to=($subStrLen) do={
			:set start (j - 1)
			:local char [:pick $subStr $start $j]
			:local num [:tonum $char]
			
			:set dec ($dec + ($num * (1 << ($subStrLen - $j))))
		}
	
		:set number $dec
		:local hexadec "0"
		:local remainder 0
		:if ($number > 0) do={:set hexadec ""}
		:while ( $number > 0 ) do={
			:set remainder ($number % 16)
			:set number (($number - $remainder) / 16)
			:set hexadec ([:pick $hexSymbSet $remainder] . $hexadec)
		} 
		:if ([:len $hexadec] = 1) do={:set hexadec "0$hexadec"}
		
		:local end (i + 1)
		:local startChar [:pick $messageBinary $i $end]
		:local charNum [:tonum $startChar]
		
		:local numInMArray [:tonum $hexadec]
		
		:if ($charNum = 1) do={
			:set numInMArray ($numInMArray | 0x80000000)
			:set dec (-1 * $numInMArray)
		}
		
		if ([:len $dec] > 0) do={
			:set ($mArray->($i / 32)) $dec
		}
		
		:if ($Debug > 0) do={
			:put ("Iteration: $i $subStr $dec")
		}
	}

	:local integerCount [:len $mArray]
	
	:local intArray []
	
	:local j 0
	
	:for i from 0 to=($integerCount - 1) step=16 do={
		:for j from 0 to=15 do={
			:set ($intArray->$j) ($mArray->($j + $i))
		}
		:for j from 16 to=79 do={
			:local x (($intArray->($j - 3)) ^ ($intArray->($j - 8)) ^ ($intArray->($j - 14)) ^ ($intArray->($j - 16)))
			:if ($x >= 0) do={
				:set leftrotate (((($x << 1) | (($x >> 31) )) & $amp ))
			} else={
				:set left ($x << 1)
				:set right ((((($x >> 1) & $x7F) | $x40) >> 30))
				:set leftrotate ((($left) | ($right)) & $amp )
			}
			:if ($leftrotate > $x7F) do={
				:set leftrotate ($leftrotate - $x100)
			}
			:set ($intArray->$j) $leftrotate
		}
		
		:local A $h1
		:local B $h2
		:local C $h3
		:local D $h4
		:local E $h5
		:local t 0
		
		:for x from 0  to=19 do={
			:if ($A >= 0) do={
				:set leftrotate ((($A << 5) | (($A >> 27) )) & $amp)
			} else={
				:set left ($A << 5)
				:set right ((((($A >> 1) & $x7F) | $x40) >> 26))
				:set leftrotate ((($left) | ($right)) & $amp )
			}
			:if ($leftrotate > $x7F) do={
				:set leftrotate ($leftrotate - $x100)
			}
			:local nB ((-1 - $B) & $amp)
			:local brackets (($B & $C) | ($nB & $D))
			:local fromArray ($intArray->($x))
			:set t (($leftrotate + $brackets + $E + $fromArray + $k1) & $amp)
			:if ($t > $x7F) do={
				:set t ($t - $x100)
			}
			:set E $D
			:set D $C
			:if ($B >= 0) do={
				:set C ((($B << 30) | (($B >> 2) )) & $amp )
			} else={
				:set left ($B << 30)
				:set right ((((($B >> 1) & $x7F) | $x40) >> 1))
				:set C ((($left) | ($right)) & $amp )
			}
			:if ($C > $x7F) do={
				:set C ($C - $x100)
			}
			:set B $A
			:set A $t
		}
		:for b from 20 to=39 do={
			:if ($A >= 0) do={
				:set leftrotate ((($A << 5) | (($A >> 27) )) & $amp)
			} else={
				:set left ($A << 5)
				:set right ((((($A >> 1) & $x7F) | $x40) >> 26))
				:set leftrotate ((($left) | ($right)) & $amp )
			}
			:if ($leftrotate > $x7F) do={
				:set leftrotate ($leftrotate - $x100)
			}
			:local brackets ($B ^ $C ^ $D)
			:local fromArray ($intArray->($b))
			:set t (($leftrotate + $brackets + $E + $fromArray + $k2) & $amp)
			:if ($t > $x7F) do={
				:set t ($t - $x100)
			}
			:set E $D
			:set D $C
			:if ($B >= 0) do={
				:set C ((($B << 30) | (($B >> 2) )) & $amp )
			} else={
				:set left ($B << 30)
				:set right ((((($B >> 1) & $x7F) | $x40) >> 1))
				:set C ((($left) | ($right)) & $amp )
			}
			:if ($C > $x7F) do={
				:set C ($C - $x100)
			}
			:set B $A
			:set A $t
		}
		:for c from 40 to=59 do={
			:if ($A >= 0) do={
				:set leftrotate ((($A << 5) | (($A >> 27) )) & $amp)
			} else={
				:set left ($A << 5)
				:set right ((((($A >> 1) & $x7F) | $x40) >> 26))
				:set leftrotate ((($left) | ($right)) & $amp )
			}
			:if ($leftrotate > $x7F) do={
				:set leftrotate ($leftrotate - $x100)
			}
			:local brackets (($B & $C) | ($B & $D) | ($C & $D))
			:local fromArray ($intArray->($c))
			:set t (($leftrotate + $brackets + $E + $fromArray + $k3)  & $amp)
			:if ($t > $x7F) do={
				:set t ($t - $x100)
			}
			:set E $D
			:set D $C
			:if ($B >= 0) do={
				:set C ((($B << 30) | (($B >> 2) )) & $amp )
			} else={
				:set left ($B << 30)
				:set right ((((($B >> 1) & $x7F) | $x40) >> 1))
				:set C ((($left) | ($right)) & $amp )
			}
			:if ($C > $x7F) do={
				:set C ($C - $x100)
			}
			:set B $A
			:set A $t
		}
		:for d from 60 to=79 do={
			:if ($A >= 0) do={
				:set leftrotate ((($A << 5) | (($A >> 27) )) & $amp)
			} else={
				:set left ($A << 5)
				:set right ((((($A >> 1) & $x7F) | $x40) >> 26))
				:set leftrotate ((($left) | ($right)) & $amp )
			}
			:if ($leftrotate > $x7F) do={
				:set leftrotate ($leftrotate - $x100)
			}
			:local brackets ($B ^ $C ^ $D)
			:local fromArray ($intArray->($d))
			:set t (($leftrotate + $brackets + $E + $fromArray + $k4) & $amp)
			:if ($t > $x7F) do={
				:set t ($t - $x100)
			}
			:set E $D
			:set D $C
			:if ($B >= 0) do={
				:set C ((($B << 30) | (($B >> 2) )) & $amp )
			} else={
				:set left ($B << 30)
				:set right ((((($B >> 1) & $x7F) | $x40) >> 1))
				:set C ((($left) | ($right)) & $amp )
			}
			:if ($C > $x7F) do={
				:set C ($C - $x100)
			}
			:set B $A
			:set A $t
		}
		
		:set h1 (($h1 + $A) & $amp )
		:if ($h1 > $x7F) do={
			:set h1 ($h1 - $x100)
		}
		:set h2 (($h2 + $B) & $amp )
		:if ($h2 > $x7F) do={
			:set h2 ($h2 - $x100)
		}
		:set h3 (($h3 + $C) & $amp )
		:if ($h3 > $x7F) do={
			:set h3 ($h3 - $x100)
		}
		:set h4 (($h4 + $D) & $amp )
		:if ($h4 > $x7F) do={
			:set h4 ($h4 - $x100)
		}
		:set h5 (($h5 + $E) & $amp ) 
		:if ($h5 > $x7F) do={
			:set h5 ($h5 - $x100)
		}
	}
	:if ($Debug > 0) do={
		:put ("This is h: $h1 $h2 $h3 $h4 $h5")
	}

	:local hexdigit 8
	:local hex1 ""
	:local hex2 ""
	:local hex3 ""
	:local hex4 ""
	:local hex5 ""
	
	:for i from=0 to=(4 * ($hexdigit - 1)) step=4 do={ 
		:set hex1 ([:pick $hexSymbSet (($h1 >> $i) & $xF) ((($h1 >> $i) & $xF) + 1)] . $hex1)
	}
	
	:set hexdigit 8
	:for i from=0 to=(4 * ($hexdigit - 1)) step=4 do={ 
		:set hex2 ([:pick $hexSymbSet (($h2 >> $i) & $xF) ((($h2 >> $i) & $xF) + 1)] . $hex2)
	}
	
	:set hexdigit 8
	:for i from=0 to=(4 * ($hexdigit - 1)) step=4 do={ 
		:set hex3 ([:pick $hexSymbSet (($h3 >> $i) & $xF) ((($h3 >> $i) & $xF) + 1)] . $hex3)
	}
	
	:set hexdigit 8
	:for i from=0 to=(4 * ($hexdigit - 1)) step=4 do={ 
		:set hex4 ([:pick $hexSymbSet (($h4 >> $i) & $xF) ((($h4 >> $i) & $xF) + 1)] . $hex4)
	}
	
	:set hexdigit 8
	:for i from=0 to=(4 * ($hexdigit - 1)) step=4 do={ 
		:set hex5 ([:pick $hexSymbSet (($h5 >> $i) & $xF) ((($h5 >> $i) & $xF) + 1)] . $hex5)
	}
	
	:local result "$hex1$hex2$hex3$hex4$hex5"
	
	:if ($Debug > 0) do={
		:put ("THIS IS HEX: $hex1 $hex2 $hex3 $hex4 $hex5")
		:put ("MArray  Length: $integerCount")
		:put ("Message Length: $binaryString $binaryLength")
		:put ("End bit Length: $endBitLength $binaryZeros")
		:put ("Message Binary: $messageBinary $mLength")
		:put ("THIS IS RESULT: $result")
	}
	
	:return $result;
} 

/system script run str2sha1
:global str2sha1;

:local answer [$str2sha1 "This is text for sha1 in RouterOS"];
:put "this is result $answer"