metasploit-framework/data/john/confs/john.conf

#
# This file is part of John the Ripper password cracker,
# Copyright (c) 1996-2006,2008-2011 by Solar Designer
#
# ...with changes in the jumbo patch, by various authors
#

#
# This file uses rules from the KoreLogic set published
# online at: http://contest.korelogic.com/rules.html
#

[Options]
# Wordlist file name, to be used in batch mode
Wordlist = $JOHN/password.lst
# Default Markov mode settings
Statsfile = $JOHN/stats
MkvLvl = 200
MkvMaxLen = 12
# Use idle cycles only
Idle = Y
# Crash recovery file saving delay in seconds
Save = 600
# Beep when a password is found (who needs this anyway?)
Beep = N

# Automagically disable OMP if MPI is used (set to N if
# you want to run one MPI process per multi-core host)
MPIOMPmutex = Y

# Print a notice if disabling OMP (when MPIOMPmutex = Y)
# or when running OMP and MPI at the same time
MPIOMPverbose = Y

# Time formatting string used in status ETA.
# %c  means 'local' specific canonical form, such as:
# 05/06/11 18:10:34
#
# Other examples
# %d/%m/%y %H:%M   (day/mon/year hour:min)
# %m/%d/%y %H:%M   (mon/day/year hour:min)
# %Y-%m-%d %H:%M   (ISO 8601 style, 2011-05-06 18:10)
TimeFormat = %c

# Threshold for showing ETA, in percent. ETA will not be
# shown if progress is less than this. If too low, early
# reported figures will be less accurate (default 0.05%)
ETAthreshold = 0.05%

# "Single crack" mode rules
[List.Rules:Single]
# Simple rules come first...
:
-s x**
-c (?a c Q
-c l Q
-s-c x** /?u l
# These were not included in crackers I've seen, but are pretty efficient,
# so I include them near the beginning
>6 '6
>7 '7 l
-c >6 '6 /?u l
>5 '5
# Weird order, eh? Can't do anything about it, the order is based on the
# number of successful cracks...
<* d
r c
-c <* (?a d c
-c >5 '5 /?u l
-c u Q
-c )?a r l
-[:c] <* !?A \p1[lc] p
-c <* c Q d
-c >7 '7 /?u
>4 '4 l
-c <+ (?l c r
-c <+ )?l l Tm
>3 '3
-c >4 '4 /?u
-c >3 '3 /?u l
-c u Q r
<* d M 'l f Q
-c <* l Q d M 'l f Q
# About 50% of single-mode-crackable passwords get cracked by now...
# >2 x12 ... >8 x18
>[2-8] x1\1
>9 \[
# >3 x22 ... >9 x28
>[3-9] x2\p[2-8]
# >4 x32 ... >9 x37
>[4-9] x3\p[2-7]
# >2 x12 /?u l ... >8 x18 /?u l
-c >[2-8] x1\1 /?u l
-c >9 \[ /?u l
# >3 x22 /?u l ... >9 x28 /?u l
-c >[3-9] x2\p[2-8] /?u l
# >4 x32 /?u l ... >9 x37 /?u l
-c >[4-9] x3\p[2-7] /?u l
# Now to the suffix stuff...
<* l $[1-9!0a-rt-z"-/:-@\[-`{-~]
-c <* (?a c $[1-9!0a-rt-z"-/:-@\[-`{-~]
-[:c] <* !?A (?\p1[za] \p1[lc] $s M 'l p Q X0z0 'l $s
-[:c] <* /?A (?\p1[za] \p1[lc] $s
<* l r $[1-9!]
-c <* /?a u $[1-9!]
-[:c] <- (?\p1[za] \p1[lc] Az"'s"
-[:c] <- (?\p1[za] \p1[lc] Az"!!"
-[:c] (?\p1[za] \p1[lc] $! <- Az"!!"
# Removing vowels...
-[:c] /?v @?v >2 (?\p1[za] \p1[lc]
/?v @?v >2 <* d
# crack -> cracked, crack -> cracking
<* l [PI]
-c <* l [PI] (?a c
# mary -> marie
-[:c] <* (?\p1[za] \p1[lc] )y omi $e
# marie -> mary
-[:c] <* (?\p1[za] \p1[lc] )e \] )i val1 oay
# The following are some 3l33t rules
-[:c] l /[aelos] s\0\p[4310$] (?\p1[za] \p1[:c]
-[:c] l /a /[elos] sa4 s\0\p[310$] (?\p1[za] \p1[:c]
-[:c] l /e /[los] se3 s\0\p[10$] (?\p1[za] \p1[:c]
-[:c] l /l /[os] sl1 s\0\p[0$] (?\p1[za] \p1[:c]
-[:c] l /o /s so0 ss$ (?\p1[za] \p1[:c]
-[:c] l /a /e /[los] sa4 se3 s\0\p[10$] (?\p1[za] \p1[:c]
-[:c] l /a /l /[os] sa4 sl1 s\0\p[0$] (?\p1[za] \p1[:c]
-[:c] l /a /o /s sa4 so0 ss$ (?\p1[za] \p1[:c]
-[:c] l /e /l /[os] se3 sl1 s\0\p[0$] (?\p1[za] \p1[:c]
-[:c] l /[el] /o /s s\0\p[31] so0 ss$ (?\p1[za] \p1[:c]
-[:c] l /a /e /l /[os] sa4 se3 sl1 s\0\p[0$] (?\p1[za] \p1[:c]
-[:c] l /a /[el] /o /s sa4 s\0\p[31] so0 ss$ (?\p1[za] \p1[:c]
-[:c] l /e /l /o /s se3 sl1 so0 ss$ (?\p1[za] \p1[:c]
-[:c] l /a /e /l /o /s sa4 se3 sl1 so0 ss$ (?\p1[za] \p1[:c]
# Now to the prefix stuff...
l ^[1a-z2-90]
-c l Q ^[A-Z]
^[A-Z]
l ^["-/:-@\[-`{-~]
-[:c] <9 (?a \p1[lc] A0"[tT]he"
-[:c] <9 (?a \p1[lc] A0"[aA]my"
-[:c] <9 (?a \p1[lc] A0"[mdMD]r"
-[:c] <9 (?a \p1[lc] A0"[mdMD]r."
-[:c] <9 (?a \p1[lc] A0"__"
<- !?A l p ^[240-9]
# Some word pair rules...
# johnsmith -> JohnSmith, johnSmith
-p-c (?a 2 (?a c 1 [cl]
# JohnSmith -> john smith, john_smith, john-smith
-p 1 <- $[ _\-] + l
# JohnSmith -> John smith, John_smith, John-smith
-p-c 1 <- (?a c $[ _\-] 2 l
# JohnSmith -> john Smith, john_Smith, john-Smith
-p-c 1 <- l $[ _\-] 2 (?a c
# johnsmith -> John Smith, John_Smith, John-Smith
-p-c 1 <- (?a c $[ _\-] 2 (?a c
# Applying different simple rules to each of the two words
-p-[c:] 1 \p1[ur] 2 l
-p-c 2 (?a c 1 [ur]
-p-[c:] 1 l 2 \p1[ur]
-p-c 1 (?a c 2 [ur]
# jsmith -> smithj, etc...
-[:c] (?a \p1[lc] [{}]
-[:c] (?a \p1[lc] [{}] \0
# Toggle case...
-c <+ )?u l Tm
-c T0 Q M c Q l Q u Q C Q X0z0 'l
-c T[1-9A-E] Q M l Tm Q C Q u Q l Q c Q X0z0 'l
-c l Q T[1-9A-E] Q M T\0 Q l Tm Q C Q u Q X0z0 'l
-c >2 <G %2?a [lu] T0 M T2 T4 T6 T8 TA TC TE Q M l Tm Q X0z0 'l
-c >2 /?l /?u t Q M c Q C Q l Tm Q X0z0 'l
# Deleting chars...
>[2-8] D\p[1-7]
>[8-9A-E] D\1
-c /?u >[2-8] D\p[1-7] l
-c /?u >[8-9A-E] D\1 l
=1?a \[ M c Q
-c (?a >[1-9A-E] D\1 c
# Inserting a dot...
-[:c] >3 (?a \p1[lc] i[12].
# More suffix stuff...
<- l Az"[190][0-9]"
-c <- (?a c Az"[190][0-9]"
<- l Az"[782][0-9]"
-c <- (?a c Az"[782][0-9]"
<* l $[A-Z]
-c <* (?a c $[A-Z]
# cracking -> CRACKiNG
-c u /I sIi
# Crack96 -> cRACK96
%2?a C Q
# Crack96 -> cRACK(^
/?A S Q
# Crack96 -> CRaCK96
-c /?v V Q
# Really weird charset conversions, like "england" -> "rmh;smf"
:[RL] Q
l Q [RL]
-c (?a c Q [RL]
:[RL] \0 Q
# Both prefixing and suffixing...
<- l ^[1!@#$%^&*\-=_+.?|:'"] $\1
<- l ^[({[<] $\p[)}\]>]
# The rest of two-digit suffix stuff, less common numbers...
<- l Az"[63-5][0-9]"
-c <- (?a c Az"[63-5][0-9]"
# Some three-digit numbers...
-[:c] (?a \p1[lc] Az"007" <+
-[:c] (?a \p1[lc] Az"123" <+
-[:c] (?a \p1[lc] Az"[1-9]\0\0" <+
# Some [birth] years...
l Az"19[7-96-0]" <+ >-
l Az"20[01]" <+ >-
l Az"19[7-9][0-9]" <+
l Az"20[01][0-9]" <+
l Az"19[6-0][9-0]" <+
# Uncomment the following lines if you're really crazy
;# Insert/overstrike some characters...
;!?A >[1-6] l i\0[a-z]
;!?A l o0[a-z]
;!?A >[1-7] l o\0[a-z]
;# Toggle case everywhere (up to length 8), assuming that certain case
;# combinations were already tried.
;-c T1 Q M T0 Q
;-c T2 Q M T[z0] T[z1] Q
;-c T3 Q M T[z0] T[z1] T[z2] Q
;-c T4 Q M T[z0] T[z1] T[z2] T[z3] Q
;-c T5 Q M T[z0] T[z1] T[z2] T[z3] T[z4] Q
;-c T6 Q M T[z0] T[z1] T[z2] T[z3] T[z4] T[z5] Q
;-c T7 Q M T[z0] T[z1] T[z2] T[z3] T[z4] T[z5] T[z6] Q
;# Very slow stuff...
;l Az"[1-90][0-9][0-9]" <+
;-c (?a c Az"[1-90][0-9][0-9]" <+
;<[\-9] l A\p[z0]"[a-z][a-z]"
;<- l ^[a-z] $[a-z]

# Wordlist mode rules
[List.Rules:Wordlist]
# Try words as they are
:
# Lowercase every pure alphanumeric word
-c >3 !?X l Q
# Capitalize every pure alphanumeric word
-c (?a >2 !?X c Q
# Lowercase and pluralize pure alphabetic words
<* >2 !?A l p
# Lowercase pure alphabetic words and append '1'
<* >2 !?A l $1
# Capitalize pure alphabetic words and append '1'
-c <* >2 !?A c $1
# Duplicate reasonably short pure alphabetic words (fred -> fredfred)
<7 >1 !?A l d
# Lowercase and reverse pure alphabetic words
>3 !?A l M r Q
# Prefix pure alphabetic words with '1'
>2 !?A l ^1
# Uppercase pure alphanumeric words
-c >2 !?X u Q M c Q u
# Lowercase pure alphabetic words and append a digit or simple punctuation
<* >2 !?A l $[2!37954860.?]
# Words containing punctuation, which is then squeezed out, lowercase
/?p @?p >3 l
# Words with vowels removed, lowercase
/?v @?v >3 l
# Words containing whitespace, which is then squeezed out, lowercase
/?w @?w >3 l
# Capitalize and duplicate short pure alphabetic words (fred -> FredFred)
-c <7 >1 !?A c d
# Capitalize and reverse pure alphabetic words (fred -> derF)
-c <+ >2 !?A c r
# Reverse and capitalize pure alphabetic words (fred -> Derf)
-c >2 !?A l M r Q c
# Lowercase and reflect pure alphabetic words (fred -> fredderf)
<7 >1 !?A l d M 'l f Q
# Uppercase the last letter of pure alphabetic words (fred -> freD)
-c <+ >2 !?A l M r Q c r
# Prefix pure alphabetic words with '2' or '4'
>2 !?A l ^[24]
# Capitalize pure alphabetic words and append a digit or simple punctuation
-c <* >2 !?A c $[2!3957468.?0]
# Prefix pure alphabetic words with digits
>2 !?A l ^[379568]
# Capitalize and pluralize pure alphabetic words of reasonable length
-c <* >2 !?A c p
# Lowercase/capitalize pure alphabetic words of reasonable length and convert:
# crack -> cracked, crack -> cracking
-[:c] <* >2 !?A \p1[lc] M [PI] Q
# Try the second half of split passwords
-s x**
-s-c x** M l Q


# Prepend "pass"
A0"[pP][aA][sS][sS]"

# [List.Rules:KoreLogicRulesPrependYears]
A0"20[0-1][0-9]"
A0"19[3-9][0-9]"

# Notice: Your wordlist should likely be all lowercase - or you are wasting work
# [List.Rules:KoreLogicRulesAppendYears]
cAz"19[0-9][0-9]"
Az"19[0-9][0-9]"
cAz"20[01][0-9]"
Az"20[01][0-9]"


# [List.Rules:KoreLogicRulesPrependAndAppendSpecial]
cA0"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"
A0"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"


# [List.Rules:KoreLogicRulesAdd1234_Everywhere]
Az"1234"
>0A[0]"1234"
>1A[1]"1234"
>2A[2]"1234"
>3A[3]"1234"
>4A[4]"1234"
>5A[5]"1234"
>6A[6]"1234"
>7A[7]"1234"
>8A[8]"1234"
>9A[9]"1234"

# [List.Rules:KoreLogicRulesAdd123_Everywhere]
Az"123"
>0A[0]"123"
>1A[1]"123"
>2A[2]"123"
>3A[3]"123"
>4A[4]"123"
>5A[5]"123"
>6A[6]"123"
>7A[7]"123"
>8A[8]"123"
>9A[9]"123"

Az".com"
cAz".com"
Az".net"
cAz".net"
Az".org"
cAz".org"

# [List.Rules:KoreLogicRulesReplaceNumbers2Special]
/1s1!
/2s2@
/3s3#
/4s4$
/5s5%
/6s6^
/7s7&
/8s8*
/9s9(
/0s0)
/1s1!%12s2@
/1s1!%13s3#
/1s1!%14s4$
/1s1!%15s5%
/1s1!%16s6^
/1s1!%17s7&
/1s1!%18s8*
/1s1!%19s9(
/1s1!%10s0)
/2s2@%13s3#
/2s2@%14s4$
/2s2@%15s5%
/2s2@%16s6^
/2s2@%17s7&
/2s2@%18s8*
/2s2@%19s9(
/2s2@%10s0)
/3s3#%14s4$
/3s3#%15s5%
/3s3#%16s6^
/3s3#%17s7&
/3s3#%18s8*
/3s3#%19s9(
/3s3#%10s0)
/4s4$%15s5%
/4s4$%16s6^
/4s4$%17s7&
/4s4$%18s8*
/4s4$%19s9(
/4s4$%10s0)
/5s5%%16s6^
/5s5%%17s7&
/5s5%%18s8*
/5s5%%19s9(
/5s5%%10s0)
/6s6^%17s7&
/6s6^%18s8*
/6s6^%19s9(
/6s6^%10s0)
/7s7&%18s8*
/7s7&%19s9(
/7s7&%10s0)
/8s8*%19s9(
/8s8*%10s0)
/9s9(%10s0)


# [List.Rules:KoreLogicRulesReplaceNumbers]
/0s01
/0s02
/0s03
/0s04
/0s05
/0s06
/0s07
/0s08
/0s09
/1s10
/1s12
/1s13
/1s14
/1s15
/1s16
/1s17
/1s18
/1s19
/2s20
/2s21
/2s23
/2s24
/2s25
/2s26
/2s27
/2s28
/2s29
/3s30
/3s31
/3s32
/3s34
/3s35
/3s36
/3s37
/3s38
/3s39
/4s40
/4s41
/4s42
/4s43
/4s45
/4s46
/4s47
/4s48
/4s49
/5s50
/5s51
/5s52
/5s53
/5s54
/5s56
/5s57
/5s58
/5s59
/6s60
/6s61
/6s62
/6s63
/6s64
/6s65
/6s67
/6s68
/6s69
/7s70
/7s71
/7s72
/7s73
/7s74
/7s75
/7s76
/7s78
/7s79
/8s80
/8s81
/8s82
/8s83
/8s84
/8s85
/8s86
/8s87
/8s89
/9s90
/9s91
/9s92
/9s93
/9s94
/9s95
/9s96
/9s97
/9s98

# [List.Rules:KoreLogicRulesPrependJustSpecials]
cA0"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"
A0"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"
cA0"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*][!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"
A0"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*][!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"

# [List.Rules:KoreLogicRulesAppend1_AddSpecialEverywhere]
>4cA[0-5]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>5cA[6]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>6cA[7]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>7cA[8]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>8cA[9]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>4A[0-5]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>5A[6]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>6A[7]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>7A[8]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"
>8A[9]"[!$@#%.^&()_+\-={}|\[\]\\;':,/\<\>?`~*]"Az"1"


A0"[dD]ev"
Az"[dD]ev"
A0"[uU]at"
Az"[uU]at"
A0"[pP]rod"
Az"[pP]rod"
A0"[tT]est"
Az"[tT]est"



/asa@[:c]
/asa4[:c]
/AsA4[:c]
/AsA@[:c]
/bsb8[:c]
/BsB8[:c]
/ese3[:c]
/EsE3[:c]
/isi1[:c]
/isi![:c]
/isi|[:c]
/IsI1[:c]
/IsI![:c]
/IsI|[:c]
/lsl1[:c]
/lsl7[:c]
/lsl|[:c]
/lsl![:c]
/Lsl1[:c]
/Lsl7[:c]
/Lsl|[:c]
/Lsl![:c]
/oso0[:c]
/OsO0[:c]
/sss$[:c]
/sss5[:c]
/SsS$[:c]
/SsS5[:c]
/tst+[:c]
/TsT+[:c]
/1s1![:c]
/1s1i[:c]
/1s1I[:c]
/1s1|[:c]
/0s0o[:c]
/0s0O[:c]
/3s3e[:c]
/3s3E[:c]
/4s4a[:c]
/4s4A[:c]
/5s5s[:c]
/5s5S[:c]
/7s7l[:c]
/7s7L[:c]
/8s8b[:c]
/8s8B[:c]
/asa@/bsb8[:c]
/asa@/BsB8[:c]
/asa@/ese3[:c]
/asa@/EsE3[:c]
/asa@/isi1[:c]
/asa@/isi![:c]
/asa@/isi|[:c]
/asa@/IsI1[:c]
/asa@/IsI![:c]
/asa@/IsI|[:c]
/asa@/lsl1[:c]
/asa@/lsl7[:c]
/asa@/lsl|[:c]
/asa@/lsl![:c]
/asa@/Lsl1[:c]
/asa@/Lsl7[:c]
/asa@/Lsl|[:c]
/asa@/Lsl![:c]
/asa@/oso0[:c]
/asa@/OsO0[:c]
/asa@/sss$[:c]
/asa@/sss5[:c]
/asa@/SsS$[:c]
/asa@/SsS5[:c]
/asa@/tst+[:c]
/asa@/TsT+[:c]
/asa@/1s1![:c]
/asa@/1s1i[:c]
/asa@/1s1I[:c]
/asa@/1s1|[:c]
/asa@/0s0o[:c]
/asa@/0s0O[:c]
/asa@/3s3e[:c]
/asa@/3s3E[:c]
/asa@/4s4a[:c]
/asa@/4s4A[:c]
/asa@/5s5s[:c]
/asa@/5s5S[:c]
/asa@/7s7l[:c]
/asa@/7s7L[:c]
/asa@/8s8b[:c]
/asa@/8s8B[:c]
/asa4/AsA4[:c]
/asa4/AsA@[:c]
/asa4/bsb8[:c]
/asa4/BsB8[:c]
/asa4/ese3[:c]
/asa4/EsE3[:c]
/asa4/isi1[:c]
/asa4/isi![:c]
/asa4/isi|[:c]
/asa4/IsI1[:c]
/asa4/IsI![:c]
/asa4/IsI|[:c]
/asa4/lsl1[:c]
/asa4/lsl7[:c]
/asa4/lsl|[:c]
/asa4/lsl![:c]
/asa4/Lsl1[:c]
/asa4/Lsl7[:c]
/asa4/Lsl|[:c]
/asa4/Lsl![:c]
/asa4/oso0[:c]
/asa4/OsO0[:c]
/asa4/sss$[:c]
/asa4/sss5[:c]
/asa4/SsS$[:c]
/asa4/SsS5[:c]
/asa4/tst+[:c]
/asa4/TsT+[:c]
/asa4/1s1![:c]
/asa4/1s1i[:c]
/asa4/1s1I[:c]
/asa4/1s1|[:c]
/asa4/0s0o[:c]
/asa4/0s0O[:c]
/asa4/3s3e[:c]
/asa4/3s3E[:c]
/asa4/4s4a[:c]
/asa4/4s4A[:c]
/asa4/5s5s[:c]
/asa4/5s5S[:c]
/asa4/7s7l[:c]
/asa4/7s7L[:c]
/asa4/8s8b[:c]
/asa4/8s8B[:c]
/AsA4/asa@[:c]
/AsA4/asa4[:c]
/AsA4/BsB8[:c]
/AsA4/ese3[:c]
/AsA4/EsE3[:c]
/AsA4/isi1[:c]
/AsA4/isi![:c]
/AsA4/isi|[:c]
/AsA4/IsI1[:c]
/AsA4/IsI![:c]
/AsA4/IsI|[:c]
/AsA4/lsl1[:c]
/AsA4/lsl7[:c]
/AsA4/lsl|[:c]
/AsA4/lsl![:c]
/AsA4/Lsl1[:c]
/AsA4/Lsl7[:c]
/AsA4/Lsl|[:c]
/AsA4/Lsl![:c]
/AsA4/oso0[:c]
/AsA4/OsO0[:c]
/AsA4/sss$[:c]
/AsA4/sss5[:c]
/AsA4/SsS$[:c]
/AsA4/SsS5[:c]
/AsA4/tst+[:c]
/AsA4/TsT+[:c]
/AsA4/1s1![:c]
/AsA4/1s1i[:c]
/AsA4/1s1I[:c]
/AsA4/1s1|[:c]
/AsA4/0s0o[:c]
/AsA4/0s0O[:c]
/AsA4/3s3e[:c]
/AsA4/3s3E[:c]
/AsA4/4s4a[:c]
/AsA4/4s4A[:c]
/AsA4/5s5s[:c]
/AsA4/5s5S[:c]
/AsA4/7s7l[:c]
/AsA4/7s7L[:c]
/AsA4/8s8b[:c]
/AsA4/8s8B[:c]
/AsA@/asa@[:c]
/AsA@/asa4[:c]
/AsA@/bsb8[:c]
/AsA@/BsB8[:c]
/AsA@/ese3[:c]
/AsA@/EsE3[:c]
/AsA@/isi1[:c]
/AsA@/isi![:c]
/AsA@/isi|[:c]
/AsA@/IsI1[:c]
/AsA@/IsI![:c]
/AsA@/IsI|[:c]
/AsA@/lsl1[:c]
/AsA@/lsl7[:c]
/AsA@/lsl|[:c]
/AsA@/lsl![:c]
/AsA@/Lsl1[:c]
/AsA@/Lsl7[:c]
/AsA@/Lsl|[:c]
/AsA@/Lsl![:c]
/AsA@/oso0[:c]
/AsA@/OsO0[:c]
/AsA@/sss$[:c]
/AsA@/sss5[:c]
/AsA@/SsS$[:c]
/AsA@/SsS5[:c]
/AsA@/tst+[:c]
/AsA@/TsT+[:c]
/AsA@/1s1![:c]
/AsA@/1s1i[:c]
/AsA@/1s1I[:c]
/AsA@/1s1|[:c]
/AsA@/0s0o[:c]
/AsA@/0s0O[:c]
/AsA@/3s3e[:c]
/AsA@/3s3E[:c]
/AsA@/4s4a[:c]
/AsA@/4s4A[:c]
/AsA@/5s5s[:c]
/AsA@/5s5S[:c]
/AsA@/7s7l[:c]
/AsA@/7s7L[:c]
/AsA@/8s8b[:c]
/AsA@/8s8B[:c]
/bsb8/asa@[:c]
/bsb8/asa4[:c]
/bsb8/AsA4[:c]
/bsb8/AsA@[:c]
/bsb8/BsB8[:c]
/bsb8/ese3[:c]
/bsb8/EsE3[:c]
/bsb8/isi1[:c]
/bsb8/isi![:c]
/bsb8/isi|[:c]
/bsb8/IsI1[:c]
/bsb8/IsI![:c]
/bsb8/IsI|[:c]
/bsb8/lsl1[:c]
/bsb8/lsl7[:c]
/bsb8/lsl|[:c]
/bsb8/lsl![:c]
/bsb8/Lsl1[:c]
/bsb8/Lsl7[:c]
/bsb8/Lsl|[:c]
/bsb8/Lsl![:c]
/bsb8/oso0[:c]
/bsb8/OsO0[:c]
/bsb8/sss$[:c]
/bsb8/sss5[:c]
/bsb8/SsS$[:c]
/bsb8/SsS5[:c]
/bsb8/tst+[:c]
/bsb8/TsT+[:c]
/bsb8/1s1![:c]
/bsb8/1s1i[:c]
/bsb8/1s1I[:c]
/bsb8/1s1|[:c]
/bsb8/0s0o[:c]
/bsb8/0s0O[:c]
/bsb8/3s3e[:c]
/bsb8/3s3E[:c]
/bsb8/4s4a[:c]
/bsb8/4s4A[:c]
/bsb8/5s5s[:c]
/bsb8/5s5S[:c]
/bsb8/7s7l[:c]
/bsb8/7s7L[:c]
/bsb8/8s8b[:c]
/bsb8/8s8B[:c]
/BsB8/asa@[:c]
/BsB8/asa4[:c]
/BsB8/AsA4[:c]
/BsB8/AsA@[:c]
/BsB8/bsb8[:c]
/BsB8/ese3[:c]
/BsB8/EsE3[:c]
/BsB8/isi1[:c]
/BsB8/isi![:c]
/BsB8/isi|[:c]
/BsB8/IsI1[:c]
/BsB8/IsI![:c]
/BsB8/IsI|[:c]
/BsB8/lsl1[:c]
/BsB8/lsl7[:c]
/BsB8/lsl|[:c]
/BsB8/lsl![:c]
/BsB8/Lsl1[:c]
/BsB8/Lsl7[:c]
/BsB8/Lsl|[:c]
/BsB8/Lsl![:c]
/BsB8/oso0[:c]
/BsB8/OsO0[:c]
/BsB8/sss$[:c]
/BsB8/sss5[:c]
/BsB8/SsS$[:c]
/BsB8/SsS5[:c]
/BsB8/tst+[:c]
/BsB8/TsT+[:c]
/BsB8/1s1![:c]
/BsB8/1s1i[:c]
/BsB8/1s1I[:c]
/BsB8/1s1|[:c]
/BsB8/0s0o[:c]
/BsB8/0s0O[:c]
/BsB8/3s3e[:c]
/BsB8/3s3E[:c]
/BsB8/4s4a[:c]
/BsB8/4s4A[:c]
/BsB8/5s5s[:c]
/BsB8/5s5S[:c]
/BsB8/7s7l[:c]
/BsB8/7s7L[:c]
/BsB8/8s8b[:c]
/BsB8/8s8B[:c]
/ese3/asa@[:c]
/ese3/asa4[:c]
/ese3/AsA4[:c]
/ese3/AsA@[:c]
/ese3/bsb8[:c]
/ese3/BsB8[:c]
/ese3/EsE3[:c]
/ese3/isi1[:c]
/ese3/isi![:c]
/ese3/isi|[:c]
/ese3/IsI1[:c]
/ese3/IsI![:c]
/ese3/IsI|[:c]
/ese3/lsl1[:c]
/ese3/lsl7[:c]
/ese3/lsl|[:c]
/ese3/lsl![:c]
/ese3/Lsl1[:c]
/ese3/Lsl7[:c]
/ese3/Lsl|[:c]
/ese3/Lsl![:c]
/ese3/oso0[:c]
/ese3/OsO0[:c]
/ese3/sss$[:c]
/ese3/sss5[:c]
/ese3/SsS$[:c]
/ese3/SsS5[:c]
/ese3/tst+[:c]
/ese3/TsT+[:c]
/ese3/1s1![:c]
/ese3/1s1i[:c]
/ese3/1s1I[:c]
/ese3/1s1|[:c]
/ese3/0s0o[:c]
/ese3/0s0O[:c]
/ese3/3s3e[:c]
/ese3/3s3E[:c]
/ese3/4s4a[:c]
/ese3/4s4A[:c]
/ese3/5s5s[:c]
/ese3/5s5S[:c]
/ese3/7s7l[:c]
/ese3/7s7L[:c]
/ese3/8s8b[:c]
/ese3/8s8B[:c]
/EsE3/asa@[:c]
/EsE3/asa4[:c]
/EsE3/AsA4[:c]
/EsE3/AsA@[:c]
/EsE3/bsb8[:c]
/EsE3/BsB8[:c]
/EsE3/ese3[:c]
/EsE3/isi1[:c]
/EsE3/isi![:c]
/EsE3/isi|[:c]
/EsE3/IsI1[:c]
/EsE3/IsI![:c]
/EsE3/IsI|[:c]
/EsE3/lsl1[:c]
/EsE3/lsl7[:c]
/EsE3/lsl|[:c]
/EsE3/lsl![:c]
/EsE3/Lsl1[:c]
/EsE3/Lsl7[:c]
/EsE3/Lsl|[:c]
/EsE3/Lsl![:c]
/EsE3/oso0[:c]
/EsE3/OsO0[:c]
/EsE3/sss$[:c]
/EsE3/sss5[:c]
/EsE3/SsS$[:c]
/EsE3/SsS5[:c]
/EsE3/tst+[:c]
/EsE3/TsT+[:c]
/EsE3/1s1![:c]
/EsE3/1s1i[:c]
/EsE3/1s1I[:c]
/EsE3/1s1|[:c]
/EsE3/0s0o[:c]
/EsE3/0s0O[:c]
/EsE3/3s3e[:c]
/EsE3/3s3E[:c]
/EsE3/4s4a[:c]
/EsE3/4s4A[:c]
/EsE3/5s5s[:c]
/EsE3/5s5S[:c]
/EsE3/7s7l[:c]
/EsE3/7s7L[:c]
/EsE3/8s8b[:c]
/EsE3/8s8B[:c]
/isi1/asa@[:c]
/isi1/asa4[:c]
/isi1/AsA4[:c]
/isi1/AsA@[:c]
/isi1/bsb8[:c]
/isi1/BsB8[:c]
/isi1/ese3[:c]
/isi1/EsE3[:c]
/isi1/IsI1[:c]
/isi1/IsI![:c]
/isi1/IsI|[:c]
/isi1/lsl1[:c]
/isi1/lsl7[:c]
/isi1/lsl|[:c]
/isi1/lsl![:c]
/isi1/Lsl1[:c]
/isi1/Lsl7[:c]
/isi1/Lsl|[:c]
/isi1/Lsl![:c]
/isi1/oso0[:c]
/isi1/OsO0[:c]
/isi1/sss$[:c]
/isi1/sss5[:c]
/isi1/SsS$[:c]
/isi1/SsS5[:c]
/isi1/tst+[:c]
/isi1/TsT+[:c]
/isi1/1s1![:c]
/isi1/1s1i[:c]
/isi1/1s1I[:c]
/isi1/1s1|[:c]
/isi1/0s0o[:c]
/isi1/0s0O[:c]
/isi1/3s3e[:c]
/isi1/3s3E[:c]
/isi1/4s4a[:c]
/isi1/4s4A[:c]
/isi1/5s5s[:c]
/isi1/5s5S[:c]
/isi1/7s7l[:c]
/isi1/7s7L[:c]
/isi1/8s8b[:c]
/isi1/8s8B[:c]
/isi!/asa@[:c]
/isi!/asa4[:c]
/isi!/AsA4[:c]
/isi!/AsA@[:c]
/isi!/bsb8[:c]
/isi!/BsB8[:c]
/isi!/ese3[:c]
/isi!/EsE3[:c]
/isi!/isi1[:c]
/isi!/isi|[:c]
/isi!/IsI1[:c]
/isi!/IsI![:c]
/isi!/IsI|[:c]
/isi!/lsl1[:c]
/isi!/lsl7[:c]
/isi!/lsl|[:c]
/isi!/lsl![:c]
/isi!/Lsl1[:c]
/isi!/Lsl7[:c]
/isi!/Lsl|[:c]
/isi!/Lsl![:c]
/isi!/oso0[:c]
/isi!/OsO0[:c]
/isi!/sss$[:c]
/isi!/sss5[:c]
/isi!/SsS$[:c]
/isi!/SsS5[:c]
/isi!/tst+[:c]
/isi!/TsT+[:c]
/isi!/1s1![:c]
/isi!/1s1i[:c]
/isi!/1s1I[:c]
/isi!/1s1|[:c]
/isi!/0s0o[:c]
/isi!/0s0O[:c]
/isi!/3s3e[:c]
/isi!/3s3E[:c]
/isi!/4s4a[:c]
/isi!/4s4A[:c]
/isi!/5s5s[:c]
/isi!/5s5S[:c]
/isi!/7s7l[:c]
/isi!/7s7L[:c]
/isi!/8s8b[:c]
/isi!/8s8B[:c]
/isi|/asa@[:c]
/isi|/asa4[:c]
/isi|/AsA4[:c]
/isi|/AsA@[:c]
/isi|/bsb8[:c]
/isi|/BsB8[:c]
/isi|/ese3[:c]
/isi|/EsE3[:c]
/isi|/isi1[:c]
/isi|/isi![:c]
/isi|/IsI1[:c]
/isi|/IsI![:c]
/isi|/IsI|[:c]
/isi|/lsl1[:c]
/isi|/lsl7[:c]
/isi|/lsl|[:c]
/isi|/lsl![:c]
/isi|/Lsl1[:c]
/isi|/Lsl7[:c]
/isi|/Lsl|[:c]
/isi|/Lsl![:c]
/isi|/oso0[:c]
/isi|/OsO0[:c]
/isi|/sss$[:c]
/isi|/sss5[:c]
/isi|/SsS$[:c]
/isi|/SsS5[:c]
/isi|/tst+[:c]
/isi|/TsT+[:c]
/isi|/1s1![:c]
/isi|/1s1i[:c]
/isi|/1s1I[:c]
/isi|/1s1|[:c]
/isi|/0s0o[:c]
/isi|/0s0O[:c]
/isi|/3s3e[:c]
/isi|/3s3E[:c]
/isi|/4s4a[:c]
/isi|/4s4A[:c]
/isi|/5s5s[:c]
/isi|/5s5S[:c]
/isi|/7s7l[:c]
/isi|/7s7L[:c]
/isi|/8s8b[:c]
/isi|/8s8B[:c]
/IsI1/asa@[:c]
/IsI1/asa4[:c]
/IsI1/AsA4[:c]
/IsI1/AsA@[:c]
/IsI1/bsb8[:c]
/IsI1/BsB8[:c]
/IsI1/ese3[:c]
/IsI1/EsE3[:c]
/IsI1/isi1[:c]
/IsI1/isi![:c]
/IsI1/isi|[:c]
/IsI1/lsl1[:c]
/IsI1/lsl7[:c]
/IsI1/lsl|[:c]
/IsI1/lsl![:c]
/IsI1/Lsl1[:c]
/IsI1/Lsl7[:c]
/IsI1/Lsl|[:c]
/IsI1/Lsl![:c]
/IsI1/oso0[:c]
/IsI1/OsO0[:c]
/IsI1/sss$[:c]
/IsI1/sss5[:c]
/IsI1/SsS$[:c]
/IsI1/SsS5[:c]
/IsI1/tst+[:c]
/IsI1/TsT+[:c]
/IsI1/1s1![:c]
/IsI1/1s1i[:c]
/IsI1/1s1I[:c]
/IsI1/1s1|[:c]
/IsI1/0s0o[:c]
/IsI1/0s0O[:c]
/IsI1/3s3e[:c]
/IsI1/3s3E[:c]
/IsI1/4s4a[:c]
/IsI1/4s4A[:c]
/IsI1/5s5s[:c]
/IsI1/5s5S[:c]
/IsI1/7s7l[:c]
/IsI1/7s7L[:c]
/IsI1/8s8b[:c]
/IsI1/8s8B[:c]
/IsI!/asa@[:c]
/IsI!/asa4[:c]
/IsI!/AsA4[:c]
/IsI!/AsA@[:c]
/IsI!/bsb8[:c]
/IsI!/BsB8[:c]
/IsI!/ese3[:c]
/IsI!/EsE3[:c]
/IsI!/isi1[:c]
/IsI!/isi![:c]
/IsI!/isi|[:c]
/IsI!/IsI1[:c]
/IsI!/IsI|[:c]
/IsI!/lsl1[:c]
/IsI!/lsl7[:c]
/IsI!/lsl|[:c]
/IsI!/lsl![:c]
/IsI!/Lsl1[:c]
/IsI!/Lsl7[:c]
/IsI!/Lsl|[:c]
/IsI!/Lsl![:c]
/IsI!/oso0[:c]
/IsI!/OsO0[:c]
/IsI!/sss$[:c]
/IsI!/sss5[:c]
/IsI!/SsS$[:c]
/IsI!/SsS5[:c]
/IsI!/tst+[:c]
/IsI!/TsT+[:c]
/IsI!/1s1![:c]
/IsI!/1s1i[:c]
/IsI!/1s1I[:c]
/IsI!/1s1|[:c]
/IsI!/0s0o[:c]
/IsI!/0s0O[:c]
/IsI!/3s3e[:c]
/IsI!/3s3E[:c]
/IsI!/4s4a[:c]
/IsI!/4s4A[:c]
/IsI!/5s5s[:c]
/IsI!/5s5S[:c]
/IsI!/7s7l[:c]
/IsI!/7s7L[:c]
/IsI!/8s8b[:c]
/IsI!/8s8B[:c]
/IsI|/asa@[:c]
/IsI|/asa4[:c]
/IsI|/AsA4[:c]
/IsI|/AsA@[:c]
/IsI|/bsb8[:c]
/IsI|/BsB8[:c]
/IsI|/ese3[:c]
/IsI|/EsE3[:c]
/IsI|/isi1[:c]
/IsI|/isi![:c]
/IsI|/isi|[:c]
/IsI|/IsI1[:c]
/IsI|/IsI![:c]
/IsI|/lsl1[:c]
/IsI|/lsl7[:c]
/IsI|/lsl|[:c]
/IsI|/lsl![:c]
/IsI|/Lsl1[:c]
/IsI|/Lsl7[:c]
/IsI|/Lsl|[:c]
/IsI|/Lsl![:c]
/IsI|/oso0[:c]
/IsI|/OsO0[:c]
/IsI|/sss$[:c]
/IsI|/sss5[:c]
/IsI|/SsS$[:c]
/IsI|/SsS5[:c]
/IsI|/tst+[:c]
/IsI|/TsT+[:c]
/IsI|/1s1![:c]
/IsI|/1s1i[:c]
/IsI|/1s1I[:c]
/IsI|/1s1|[:c]
/IsI|/0s0o[:c]
/IsI|/0s0O[:c]
/IsI|/3s3e[:c]
/IsI|/3s3E[:c]
/IsI|/4s4a[:c]
/IsI|/4s4A[:c]
/IsI|/5s5s[:c]
/IsI|/5s5S[:c]
/IsI|/7s7l[:c]
/IsI|/7s7L[:c]
/IsI|/8s8b[:c]
/IsI|/8s8B[:c]
/lsl1/asa@[:c]
/lsl1/asa4[:c]
/lsl1/AsA4[:c]
/lsl1/AsA@[:c]
/lsl1/bsb8[:c]
/lsl1/BsB8[:c]
/lsl1/ese3[:c]
/lsl1/EsE3[:c]
/lsl1/isi1[:c]
/lsl1/isi![:c]
/lsl1/isi|[:c]
/lsl1/IsI1[:c]
/lsl1/IsI![:c]
/lsl1/IsI|[:c]
/lsl1/Lsl1[:c]
/lsl1/Lsl7[:c]
/lsl1/Lsl|[:c]
/lsl1/Lsl![:c]
/lsl1/oso0[:c]
/lsl1/OsO0[:c]
/lsl1/sss$[:c]
/lsl1/sss5[:c]
/lsl1/SsS$[:c]
/lsl1/SsS5[:c]
/lsl1/tst+[:c]
/lsl1/TsT+[:c]
/lsl1/1s1![:c]
/lsl1/1s1i[:c]
/lsl1/1s1I[:c]
/lsl1/1s1|[:c]
/lsl1/0s0o[:c]
/lsl1/0s0O[:c]
/lsl1/3s3e[:c]
/lsl1/3s3E[:c]
/lsl1/4s4a[:c]
/lsl1/4s4A[:c]
/lsl1/5s5s[:c]
/lsl1/5s5S[:c]
/lsl1/7s7l[:c]
/lsl1/7s7L[:c]
/lsl1/8s8b[:c]
/lsl1/8s8B[:c]
/lsl7/asa@[:c]
/lsl7/asa4[:c]
/lsl7/AsA4[:c]
/lsl7/AsA@[:c]
/lsl7/bsb8[:c]
/lsl7/BsB8[:c]
/lsl7/ese3[:c]
/lsl7/EsE3[:c]
/lsl7/isi1[:c]
/lsl7/isi![:c]
/lsl7/isi|[:c]
/lsl7/IsI1[:c]
/lsl7/IsI![:c]
/lsl7/IsI|[:c]
/lsl7/lsl1[:c]
/lsl7/lsl|[:c]
/lsl7/lsl![:c]
/lsl7/Lsl1[:c]
/lsl7/Lsl7[:c]
/lsl7/Lsl|[:c]
/lsl7/Lsl![:c]
/lsl7/oso0[:c]
/lsl7/OsO0[:c]
/lsl7/sss$[:c]
/lsl7/sss5[:c]
/lsl7/SsS$[:c]
/lsl7/SsS5[:c]
/lsl7/tst+[:c]
/lsl7/TsT+[:c]
/lsl7/1s1![:c]
/lsl7/1s1i[:c]
/lsl7/1s1I[:c]
/lsl7/1s1|[:c]
/lsl7/0s0o[:c]
/lsl7/0s0O[:c]
/lsl7/3s3e[:c]
/lsl7/3s3E[:c]
/lsl7/4s4a[:c]
/lsl7/4s4A[:c]
/lsl7/5s5s[:c]
/lsl7/5s5S[:c]
/lsl7/7s7l[:c]
/lsl7/7s7L[:c]
/lsl7/8s8b[:c]
/lsl7/8s8B[:c]
/lsl|/asa@[:c]
/lsl|/asa4[:c]
/lsl|/AsA4[:c]
/lsl|/AsA@[:c]
/lsl|/bsb8[:c]
/lsl|/BsB8[:c]
/lsl|/ese3[:c]
/lsl|/EsE3[:c]
/lsl|/isi1[:c]
/lsl|/isi![:c]
/lsl|/isi|[:c]
/lsl|/IsI1[:c]
/lsl|/IsI![:c]
/lsl|/IsI|[:c]
/lsl|/lsl1[:c]
/lsl|/lsl7[:c]
/lsl|/lsl![:c]
/lsl|/Lsl1[:c]
/lsl|/Lsl7[:c]
/lsl|/Lsl|[:c]
/lsl|/Lsl![:c]
/lsl|/oso0[:c]
/lsl|/OsO0[:c]
/lsl|/sss$[:c]
/lsl|/sss5[:c]
/lsl|/SsS$[:c]
/lsl|/SsS5[:c]
/lsl|/tst+[:c]
/lsl|/TsT+[:c]
/lsl|/1s1![:c]
/lsl|/1s1i[:c]
/lsl|/1s1I[:c]
/lsl|/1s1|[:c]
/lsl|/0s0o[:c]
/lsl|/0s0O[:c]
/lsl|/3s3e[:c]
/lsl|/3s3E[:c]
/lsl|/4s4a[:c]
/lsl|/4s4A[:c]
/lsl|/5s5s[:c]
/lsl|/5s5S[:c]
/lsl|/7s7l[:c]
/lsl|/7s7L[:c]
/lsl|/8s8b[:c]
/lsl|/8s8B[:c]
/lsl!/asa@[:c]
/lsl!/asa4[:c]
/lsl!/AsA4[:c]
/lsl!/AsA@[:c]
/lsl!/bsb8[:c]
/lsl!/BsB8[:c]
/lsl!/ese3[:c]
/lsl!/EsE3[:c]
/lsl!/isi1[:c]
/lsl!/isi![:c]
/lsl!/isi|[:c]
/lsl!/IsI1[:c]
/lsl!/IsI![:c]
/lsl!/IsI|[:c]
/lsl!/lsl1[:c]
/lsl!/lsl7[:c]
/lsl!/lsl|[:c]
/lsl!/Lsl1[:c]
/lsl!/Lsl7[:c]
/lsl!/Lsl|[:c]
/lsl!/Lsl![:c]
/lsl!/oso0[:c]
/lsl!/OsO0[:c]
/lsl!/sss$[:c]
/lsl!/sss5[:c]
/lsl!/SsS$[:c]
/lsl!/SsS5[:c]
/lsl!/tst+[:c]
/lsl!/TsT+[:c]
/lsl!/1s1![:c]
/lsl!/1s1i[:c]
/lsl!/1s1I[:c]
/lsl!/1s1|[:c]
/lsl!/0s0o[:c]
/lsl!/0s0O[:c]
/lsl!/3s3e[:c]
/lsl!/3s3E[:c]
/lsl!/4s4a[:c]
/lsl!/4s4A[:c]
/lsl!/5s5s[:c]
/lsl!/5s5S[:c]
/lsl!/7s7l[:c]
/lsl!/7s7L[:c]
/lsl!/8s8b[:c]
/lsl!/8s8B[:c]
/Lsl1/asa@[:c]
/Lsl1/asa4[:c]
/Lsl1/AsA4[:c]
/Lsl1/AsA@[:c]
/Lsl1/bsb8[:c]
/Lsl1/BsB8[:c]
/Lsl1/ese3[:c]
/Lsl1/EsE3[:c]
/Lsl1/isi1[:c]
/Lsl1/isi![:c]
/Lsl1/isi|[:c]
/Lsl1/IsI1[:c]
/Lsl1/IsI![:c]
/Lsl1/IsI|[:c]
/Lsl1/lsl1[:c]
/Lsl1/lsl7[:c]
/Lsl1/lsl|[:c]
/Lsl1/lsl![:c]
/Lsl1/oso0[:c]
/Lsl1/OsO0[:c]
/Lsl1/sss$[:c]
/Lsl1/sss5[:c]
/Lsl1/SsS$[:c]
/Lsl1/SsS5[:c]
/Lsl1/tst+[:c]
/Lsl1/TsT+[:c]
/Lsl1/1s1![:c]
/Lsl1/1s1i[:c]
/Lsl1/1s1I[:c]
/Lsl1/1s1|[:c]
/Lsl1/0s0o[:c]
/Lsl1/0s0O[:c]
/Lsl1/3s3e[:c]
/Lsl1/3s3E[:c]
/Lsl1/4s4a[:c]
/Lsl1/4s4A[:c]
/Lsl1/5s5s[:c]
/Lsl1/5s5S[:c]
/Lsl1/7s7l[:c]
/Lsl1/7s7L[:c]
/Lsl1/8s8b[:c]
/Lsl1/8s8B[:c]
/Lsl7/asa@[:c]
/Lsl7/asa4[:c]
/Lsl7/AsA4[:c]
/Lsl7/AsA@[:c]
/Lsl7/bsb8[:c]
/Lsl7/BsB8[:c]
/Lsl7/ese3[:c]
/Lsl7/EsE3[:c]
/Lsl7/isi1[:c]
/Lsl7/isi![:c]
/Lsl7/isi|[:c]
/Lsl7/IsI1[:c]
/Lsl7/IsI![:c]
/Lsl7/IsI|[:c]
/Lsl7/lsl1[:c]
/Lsl7/lsl7[:c]
/Lsl7/lsl|[:c]
/Lsl7/lsl![:c]
/Lsl7/Lsl1[:c]
/Lsl7/Lsl|[:c]
/Lsl7/Lsl![:c]
/Lsl7/oso0[:c]
/Lsl7/OsO0[:c]
/Lsl7/sss$[:c]
/Lsl7/sss5[:c]
/Lsl7/SsS$[:c]
/Lsl7/SsS5[:c]
/Lsl7/tst+[:c]
/Lsl7/TsT+[:c]
/Lsl7/1s1![:c]
/Lsl7/1s1i[:c]
/Lsl7/1s1I[:c]
/Lsl7/1s1|[:c]
/Lsl7/0s0o[:c]
/Lsl7/0s0O[:c]
/Lsl7/3s3e[:c]
/Lsl7/3s3E[:c]
/Lsl7/4s4a[:c]
/Lsl7/4s4A[:c]
/Lsl7/5s5s[:c]
/Lsl7/5s5S[:c]
/Lsl7/7s7l[:c]
/Lsl7/7s7L[:c]
/Lsl7/8s8b[:c]
/Lsl7/8s8B[:c]
/Lsl|/asa@[:c]
/Lsl|/asa4[:c]
/Lsl|/AsA4[:c]
/Lsl|/AsA@[:c]
/Lsl|/bsb8[:c]
/Lsl|/BsB8[:c]
/Lsl|/ese3[:c]
/Lsl|/EsE3[:c]
/Lsl|/isi1[:c]
/Lsl|/isi![:c]
/Lsl|/isi|[:c]
/Lsl|/IsI1[:c]
/Lsl|/IsI![:c]
/Lsl|/IsI|[:c]
/Lsl|/lsl1[:c]
/Lsl|/lsl7[:c]
/Lsl|/lsl|[:c]
/Lsl|/lsl![:c]
/Lsl|/oso0[:c]
/Lsl|/OsO0[:c]
/Lsl|/sss$[:c]
/Lsl|/sss5[:c]
/Lsl|/SsS$[:c]
/Lsl|/SsS5[:c]
/Lsl|/tst+[:c]
/Lsl|/TsT+[:c]
/Lsl|/1s1![:c]
/Lsl|/1s1i[:c]
/Lsl|/1s1I[:c]
/Lsl|/1s1|[:c]
/Lsl|/0s0o[:c]
/Lsl|/0s0O[:c]
/Lsl|/3s3e[:c]
/Lsl|/3s3E[:c]
/Lsl|/4s4a[:c]
/Lsl|/4s4A[:c]
/Lsl|/5s5s[:c]
/Lsl|/5s5S[:c]
/Lsl|/7s7l[:c]
/Lsl|/7s7L[:c]
/Lsl|/8s8b[:c]
/Lsl|/8s8B[:c]
/Lsl!/asa@[:c]
/Lsl!/asa4[:c]
/Lsl!/AsA4[:c]
/Lsl!/AsA@[:c]
/Lsl!/bsb8[:c]
/Lsl!/BsB8[:c]
/Lsl!/ese3[:c]
/Lsl!/EsE3[:c]
/Lsl!/isi1[:c]
/Lsl!/isi![:c]
/Lsl!/isi|[:c]
/Lsl!/IsI1[:c]
/Lsl!/IsI![:c]
/Lsl!/IsI|[:c]
/Lsl!/lsl1[:c]
/Lsl!/lsl7[:c]
/Lsl!/lsl|[:c]
/Lsl!/lsl![:c]
/Lsl!/oso0[:c]
/Lsl!/OsO0[:c]
/Lsl!/sss$[:c]
/Lsl!/sss5[:c]
/Lsl!/SsS$[:c]
/Lsl!/SsS5[:c]
/Lsl!/tst+[:c]
/Lsl!/TsT+[:c]
/Lsl!/1s1![:c]
/Lsl!/1s1i[:c]
/Lsl!/1s1I[:c]
/Lsl!/1s1|[:c]
/Lsl!/0s0o[:c]
/Lsl!/0s0O[:c]
/Lsl!/3s3e[:c]
/Lsl!/3s3E[:c]
/Lsl!/4s4a[:c]
/Lsl!/4s4A[:c]
/Lsl!/5s5s[:c]
/Lsl!/5s5S[:c]
/Lsl!/7s7l[:c]
/Lsl!/7s7L[:c]
/Lsl!/8s8b[:c]
/Lsl!/8s8B[:c]
/oso0/asa@[:c]
/oso0/asa4[:c]
/oso0/AsA4[:c]
/oso0/AsA@[:c]
/oso0/bsb8[:c]
/oso0/BsB8[:c]
/oso0/ese3[:c]
/oso0/EsE3[:c]
/oso0/isi1[:c]
/oso0/isi![:c]
/oso0/isi|[:c]
/oso0/IsI1[:c]
/oso0/IsI![:c]
/oso0/IsI|[:c]
/oso0/lsl1[:c]
/oso0/lsl7[:c]
/oso0/lsl|[:c]
/oso0/lsl![:c]
/oso0/Lsl1[:c]
/oso0/Lsl7[:c]
/oso0/Lsl|[:c]
/oso0/Lsl![:c]
/oso0/OsO0[:c]
/oso0/sss$[:c]
/oso0/sss5[:c]
/oso0/SsS$[:c]
/oso0/SsS5[:c]
/oso0/tst+[:c]
/oso0/TsT+[:c]
/oso0/1s1![:c]
/oso0/1s1i[:c]
/oso0/1s1I[:c]
/oso0/1s1|[:c]
/oso0/0s0o[:c]
/oso0/0s0O[:c]
/oso0/3s3e[:c]
/oso0/3s3E[:c]
/oso0/4s4a[:c]
/oso0/4s4A[:c]
/oso0/5s5s[:c]
/oso0/5s5S[:c]
/oso0/7s7l[:c]
/oso0/7s7L[:c]
/oso0/8s8b[:c]
/oso0/8s8B[:c]
/OsO0/asa@[:c]
/OsO0/asa4[:c]
/OsO0/AsA4[:c]
/OsO0/AsA@[:c]
/OsO0/bsb8[:c]
/OsO0/BsB8[:c]
/OsO0/ese3[:c]
/OsO0/EsE3[:c]
/OsO0/isi1[:c]
/OsO0/isi![:c]
/OsO0/isi|[:c]
/OsO0/IsI1[:c]
/OsO0/IsI![:c]
/OsO0/IsI|[:c]
/OsO0/lsl1[:c]
/OsO0/lsl7[:c]
/OsO0/lsl|[:c]
/OsO0/lsl![:c]
/OsO0/Lsl1[:c]
/OsO0/Lsl7[:c]
/OsO0/Lsl|[:c]
/OsO0/Lsl![:c]
/OsO0/oso0[:c]
/OsO0/sss$[:c]
/OsO0/sss5[:c]
/OsO0/SsS$[:c]
/OsO0/SsS5[:c]
/OsO0/tst+[:c]
/OsO0/TsT+[:c]
/OsO0/1s1![:c]
/OsO0/1s1i[:c]
/OsO0/1s1I[:c]
/OsO0/1s1|[:c]
/OsO0/0s0o[:c]
/OsO0/0s0O[:c]
/OsO0/3s3e[:c]
/OsO0/3s3E[:c]
/OsO0/4s4a[:c]
/OsO0/4s4A[:c]
/OsO0/5s5s[:c]
/OsO0/5s5S[:c]
/OsO0/7s7l[:c]
/OsO0/7s7L[:c]
/OsO0/8s8b[:c]
/OsO0/8s8B[:c]
/sss$/asa@[:c]
/sss$/asa4[:c]
/sss$/AsA4[:c]
/sss$/AsA@[:c]
/sss$/bsb8[:c]
/sss$/BsB8[:c]
/sss$/ese3[:c]
/sss$/EsE3[:c]
/sss$/isi1[:c]
/sss$/isi![:c]
/sss$/isi|[:c]
/sss$/IsI1[:c]
/sss$/IsI![:c]
/sss$/IsI|[:c]
/sss$/lsl1[:c]
/sss$/lsl7[:c]
/sss$/lsl|[:c]
/sss$/lsl![:c]
/sss$/Lsl1[:c]
/sss$/Lsl7[:c]
/sss$/Lsl|[:c]
/sss$/Lsl![:c]
/sss$/oso0[:c]
/sss$/OsO0[:c]
/sss$/SsS$[:c]
/sss$/SsS5[:c]
/sss$/tst+[:c]
/sss$/TsT+[:c]
/sss$/1s1![:c]
/sss$/1s1i[:c]
/sss$/1s1I[:c]
/sss$/1s1|[:c]
/sss$/0s0o[:c]
/sss$/0s0O[:c]
/sss$/3s3e[:c]
/sss$/3s3E[:c]
/sss$/4s4a[:c]
/sss$/4s4A[:c]
/sss$/5s5s[:c]
/sss$/5s5S[:c]
/sss$/7s7l[:c]
/sss$/7s7L[:c]
/sss$/8s8b[:c]
/sss$/8s8B[:c]
/sss5/asa@[:c]
/sss5/asa4[:c]
/sss5/AsA4[:c]
/sss5/AsA@[:c]
/sss5/bsb8[:c]
/sss5/BsB8[:c]
/sss5/ese3[:c]
/sss5/EsE3[:c]
/sss5/isi1[:c]
/sss5/isi![:c]
/sss5/isi|[:c]
/sss5/IsI1[:c]
/sss5/IsI![:c]
/sss5/IsI|[:c]
/sss5/lsl1[:c]
/sss5/lsl7[:c]
/sss5/lsl|[:c]
/sss5/lsl![:c]
/sss5/Lsl1[:c]
/sss5/Lsl7[:c]
/sss5/Lsl|[:c]
/sss5/Lsl![:c]
/sss5/oso0[:c]
/sss5/OsO0[:c]
/sss5/SsS$[:c]
/sss5/SsS5[:c]
/sss5/tst+[:c]
/sss5/TsT+[:c]
/sss5/1s1![:c]
/sss5/1s1i[:c]
/sss5/1s1I[:c]
/sss5/1s1|[:c]
/sss5/0s0o[:c]
/sss5/0s0O[:c]
/sss5/3s3e[:c]
/sss5/3s3E[:c]
/sss5/4s4a[:c]
/sss5/4s4A[:c]
/sss5/5s5s[:c]
/sss5/5s5S[:c]
/sss5/7s7l[:c]
/sss5/7s7L[:c]
/sss5/8s8b[:c]
/sss5/8s8B[:c]
/SsS$/asa@[:c]
/SsS$/asa4[:c]
/SsS$/AsA4[:c]
/SsS$/AsA@[:c]
/SsS$/bsb8[:c]
/SsS$/BsB8[:c]
/SsS$/ese3[:c]
/SsS$/EsE3[:c]
/SsS$/isi1[:c]
/SsS$/isi![:c]
/SsS$/isi|[:c]
/SsS$/IsI1[:c]
/SsS$/IsI![:c]
/SsS$/IsI|[:c]
/SsS$/lsl1[:c]
/SsS$/lsl7[:c]
/SsS$/lsl|[:c]
/SsS$/lsl![:c]
/SsS$/Lsl1[:c]
/SsS$/Lsl7[:c]
/SsS$/Lsl|[:c]
/SsS$/Lsl![:c]
/SsS$/oso0[:c]
/SsS$/OsO0[:c]
/SsS$/sss$[:c]
/SsS$/sss5[:c]
/SsS$/tst+[:c]
/SsS$/TsT+[:c]
/SsS$/1s1![:c]
/SsS$/1s1i[:c]
/SsS$/1s1I[:c]
/SsS$/1s1|[:c]
/SsS$/0s0o[:c]
/SsS$/0s0O[:c]
/SsS$/3s3e[:c]
/SsS$/3s3E[:c]
/SsS$/4s4a[:c]
/SsS$/4s4A[:c]
/SsS$/5s5s[:c]
/SsS$/5s5S[:c]
/SsS$/7s7l[:c]
/SsS$/7s7L[:c]
/SsS$/8s8b[:c]
/SsS$/8s8B[:c]
/SsS5/asa@[:c]
/SsS5/asa4[:c]
/SsS5/AsA4[:c]
/SsS5/AsA@[:c]
/SsS5/bsb8[:c]
/SsS5/BsB8[:c]
/SsS5/ese3[:c]
/SsS5/EsE3[:c]
/SsS5/isi1[:c]
/SsS5/isi![:c]
/SsS5/isi|[:c]
/SsS5/IsI1[:c]
/SsS5/IsI![:c]
/SsS5/IsI|[:c]
/SsS5/lsl1[:c]
/SsS5/lsl7[:c]
/SsS5/lsl|[:c]
/SsS5/lsl![:c]
/SsS5/Lsl1[:c]
/SsS5/Lsl7[:c]
/SsS5/Lsl|[:c]
/SsS5/Lsl![:c]
/SsS5/oso0[:c]
/SsS5/OsO0[:c]
/SsS5/sss$[:c]
/SsS5/sss5[:c]
/SsS5/tst+[:c]
/SsS5/TsT+[:c]
/SsS5/1s1![:c]
/SsS5/1s1i[:c]
/SsS5/1s1I[:c]
/SsS5/1s1|[:c]
/SsS5/0s0o[:c]
/SsS5/0s0O[:c]
/SsS5/3s3e[:c]
/SsS5/3s3E[:c]
/SsS5/4s4a[:c]
/SsS5/4s4A[:c]
/SsS5/5s5s[:c]
/SsS5/5s5S[:c]
/SsS5/7s7l[:c]
/SsS5/7s7L[:c]
/SsS5/8s8b[:c]
/SsS5/8s8B[:c]
/tst+/asa@[:c]
/tst+/asa4[:c]
/tst+/AsA4[:c]
/tst+/AsA@[:c]
/tst+/bsb8[:c]
/tst+/BsB8[:c]
/tst+/ese3[:c]
/tst+/EsE3[:c]
/tst+/isi1[:c]
/tst+/isi![:c]
/tst+/isi|[:c]
/tst+/IsI1[:c]
/tst+/IsI![:c]
/tst+/IsI|[:c]
/tst+/lsl1[:c]
/tst+/lsl7[:c]
/tst+/lsl|[:c]
/tst+/lsl![:c]
/tst+/Lsl1[:c]
/tst+/Lsl7[:c]
/tst+/Lsl|[:c]
/tst+/Lsl![:c]
/tst+/oso0[:c]
/tst+/OsO0[:c]
/tst+/sss$[:c]
/tst+/sss5[:c]
/tst+/SsS$[:c]
/tst+/SsS5[:c]
/tst+/TsT+[:c]
/tst+/1s1![:c]
/tst+/1s1i[:c]
/tst+/1s1I[:c]
/tst+/1s1|[:c]
/tst+/0s0o[:c]
/tst+/0s0O[:c]
/tst+/3s3e[:c]
/tst+/3s3E[:c]
/tst+/4s4a[:c]
/tst+/4s4A[:c]
/tst+/5s5s[:c]
/tst+/5s5S[:c]
/tst+/7s7l[:c]
/tst+/7s7L[:c]
/tst+/8s8b[:c]
/tst+/8s8B[:c]
/TsT+/asa@[:c]
/TsT+/asa4[:c]
/TsT+/AsA4[:c]
/TsT+/AsA@[:c]
/TsT+/bsb8[:c]
/TsT+/BsB8[:c]
/TsT+/ese3[:c]
/TsT+/EsE3[:c]
/TsT+/isi1[:c]
/TsT+/isi![:c]
/TsT+/isi|[:c]
/TsT+/IsI1[:c]
/TsT+/IsI![:c]
/TsT+/IsI|[:c]
/TsT+/lsl1[:c]
/TsT+/lsl7[:c]
/TsT+/lsl|[:c]
/TsT+/lsl![:c]
/TsT+/Lsl1[:c]
/TsT+/Lsl7[:c]
/TsT+/Lsl|[:c]
/TsT+/Lsl![:c]
/TsT+/oso0[:c]
/TsT+/OsO0[:c]
/TsT+/sss$[:c]
/TsT+/sss5[:c]
/TsT+/SsS$[:c]
/TsT+/SsS5[:c]
/TsT+/tst+[:c]
/TsT+/1s1![:c]
/TsT+/1s1i[:c]
/TsT+/1s1I[:c]
/TsT+/1s1|[:c]
/TsT+/0s0o[:c]
/TsT+/0s0O[:c]
/TsT+/3s3e[:c]
/TsT+/3s3E[:c]
/TsT+/4s4a[:c]
/TsT+/4s4A[:c]
/TsT+/5s5s[:c]
/TsT+/5s5S[:c]
/TsT+/7s7l[:c]
/TsT+/7s7L[:c]
/TsT+/8s8b[:c]
/TsT+/8s8B[:c]
/1s1!/asa@[:c]
/1s1!/asa4[:c]
/1s1!/AsA4[:c]
/1s1!/AsA@[:c]
/1s1!/bsb8[:c]
/1s1!/BsB8[:c]
/1s1!/ese3[:c]
/1s1!/EsE3[:c]
/1s1!/isi1[:c]
/1s1!/isi![:c]
/1s1!/isi|[:c]
/1s1!/IsI1[:c]
/1s1!/IsI![:c]
/1s1!/IsI|[:c]
/1s1!/lsl1[:c]
/1s1!/lsl7[:c]
/1s1!/lsl|[:c]
/1s1!/lsl![:c]
/1s1!/Lsl1[:c]
/1s1!/Lsl7[:c]
/1s1!/Lsl|[:c]
/1s1!/Lsl![:c]
/1s1!/oso0[:c]
/1s1!/OsO0[:c]
/1s1!/sss$[:c]
/1s1!/sss5[:c]
/1s1!/SsS$[:c]
/1s1!/SsS5[:c]
/1s1!/tst+[:c]
/1s1!/TsT+[:c]
/1s1!/0s0o[:c]
/1s1!/0s0O[:c]
/1s1!/3s3e[:c]
/1s1!/3s3E[:c]
/1s1!/4s4a[:c]
/1s1!/4s4A[:c]
/1s1!/5s5s[:c]
/1s1!/5s5S[:c]
/1s1!/7s7l[:c]
/1s1!/7s7L[:c]
/1s1!/8s8b[:c]
/1s1!/8s8B[:c]
/1s1i/asa@[:c]
/1s1i/asa4[:c]
/1s1i/AsA4[:c]
/1s1i/AsA@[:c]
/1s1i/bsb8[:c]
/1s1i/BsB8[:c]
/1s1i/ese3[:c]
/1s1i/EsE3[:c]
/1s1i/isi1[:c]
/1s1i/isi![:c]
/1s1i/isi|[:c]
/1s1i/IsI1[:c]
/1s1i/IsI![:c]
/1s1i/IsI|[:c]
/1s1i/lsl1[:c]
/1s1i/lsl7[:c]
/1s1i/lsl|[:c]
/1s1i/lsl![:c]
/1s1i/Lsl1[:c]
/1s1i/Lsl7[:c]
/1s1i/Lsl|[:c]
/1s1i/Lsl![:c]
/1s1i/oso0[:c]
/1s1i/OsO0[:c]
/1s1i/sss$[:c]
/1s1i/sss5[:c]
/1s1i/SsS$[:c]
/1s1i/SsS5[:c]
/1s1i/tst+[:c]
/1s1i/TsT+[:c]
/1s1i/0s0o[:c]
/1s1i/0s0O[:c]
/1s1i/3s3e[:c]
/1s1i/3s3E[:c]
/1s1i/4s4a[:c]
/1s1i/4s4A[:c]
/1s1i/5s5s[:c]
/1s1i/5s5S[:c]
/1s1i/7s7l[:c]
/1s1i/7s7L[:c]
/1s1i/8s8b[:c]
/1s1i/8s8B[:c]
/1s1I/asa@[:c]
/1s1I/asa4[:c]
/1s1I/AsA4[:c]
/1s1I/AsA@[:c]
/1s1I/bsb8[:c]
/1s1I/BsB8[:c]
/1s1I/ese3[:c]
/1s1I/EsE3[:c]
/1s1I/isi1[:c]
/1s1I/isi![:c]
/1s1I/isi|[:c]
/1s1I/IsI1[:c]
/1s1I/IsI![:c]
/1s1I/IsI|[:c]
/1s1I/lsl1[:c]
/1s1I/lsl7[:c]
/1s1I/lsl|[:c]
/1s1I/lsl![:c]
/1s1I/Lsl1[:c]
/1s1I/Lsl7[:c]
/1s1I/Lsl|[:c]
/1s1I/Lsl![:c]
/1s1I/oso0[:c]
/1s1I/OsO0[:c]
/1s1I/sss$[:c]
/1s1I/sss5[:c]
/1s1I/SsS$[:c]
/1s1I/SsS5[:c]
/1s1I/tst+[:c]
/1s1I/TsT+[:c]
/1s1I/1s1![:c]
/1s1I/1s1i[:c]
/1s1I/1s1|[:c]
/1s1I/0s0o[:c]
/1s1I/0s0O[:c]
/1s1I/3s3e[:c]
/1s1I/3s3E[:c]
/1s1I/4s4a[:c]
/1s1I/4s4A[:c]
/1s1I/5s5s[:c]
/1s1I/5s5S[:c]
/1s1I/7s7l[:c]
/1s1I/7s7L[:c]
/1s1I/8s8b[:c]
/1s1I/8s8B[:c]
/1s1|/asa@[:c]
/1s1|/asa4[:c]
/1s1|/AsA4[:c]
/1s1|/AsA@[:c]
/1s1|/bsb8[:c]
/1s1|/BsB8[:c]
/1s1|/ese3[:c]
/1s1|/EsE3[:c]
/1s1|/isi1[:c]
/1s1|/isi![:c]
/1s1|/isi|[:c]
/1s1|/IsI1[:c]
/1s1|/IsI![:c]
/1s1|/IsI|[:c]
/1s1|/lsl1[:c]
/1s1|/lsl7[:c]
/1s1|/lsl|[:c]
/1s1|/lsl![:c]
/1s1|/Lsl1[:c]
/1s1|/Lsl7[:c]
/1s1|/Lsl|[:c]
/1s1|/Lsl![:c]
/1s1|/oso0[:c]
/1s1|/OsO0[:c]
/1s1|/sss$[:c]
/1s1|/sss5[:c]
/1s1|/SsS$[:c]
/1s1|/SsS5[:c]
/1s1|/tst+[:c]
/1s1|/TsT+[:c]
/1s1|/1s1![:c]
/1s1|/1s1i[:c]
/1s1|/1s1I[:c]
/1s1|/0s0o[:c]
/1s1|/0s0O[:c]
/1s1|/3s3e[:c]
/1s1|/3s3E[:c]
/1s1|/4s4a[:c]
/1s1|/4s4A[:c]
/1s1|/5s5s[:c]
/1s1|/5s5S[:c]
/1s1|/7s7l[:c]
/1s1|/7s7L[:c]
/1s1|/8s8b[:c]
/1s1|/8s8B[:c]
/0s0o/asa@[:c]
/0s0o/asa4[:c]
/0s0o/AsA4[:c]
/0s0o/AsA@[:c]
/0s0o/bsb8[:c]
/0s0o/BsB8[:c]
/0s0o/ese3[:c]
/0s0o/EsE3[:c]
/0s0o/isi1[:c]
/0s0o/isi![:c]
/0s0o/isi|[:c]
/0s0o/IsI1[:c]
/0s0o/IsI![:c]
/0s0o/IsI|[:c]
/0s0o/lsl1[:c]
/0s0o/lsl7[:c]
/0s0o/lsl|[:c]
/0s0o/lsl![:c]
/0s0o/Lsl1[:c]
/0s0o/Lsl7[:c]
/0s0o/Lsl|[:c]
/0s0o/Lsl![:c]
/0s0o/oso0[:c]
/0s0o/OsO0[:c]
/0s0o/sss$[:c]
/0s0o/sss5[:c]
/0s0o/SsS$[:c]
/0s0o/SsS5[:c]
/0s0o/tst+[:c]
/0s0o/TsT+[:c]
/0s0o/1s1![:c]
/0s0o/1s1i[:c]
/0s0o/1s1I[:c]
/0s0o/1s1|[:c]
/0s0o/3s3e[:c]
/0s0o/3s3E[:c]
/0s0o/4s4a[:c]
/0s0o/4s4A[:c]
/0s0o/5s5s[:c]
/0s0o/5s5S[:c]
/0s0o/7s7l[:c]
/0s0o/7s7L[:c]
/0s0o/8s8b[:c]
/0s0o/8s8B[:c]
/0s0O/asa@[:c]
/0s0O/asa4[:c]
/0s0O/AsA4[:c]
/0s0O/AsA@[:c]
/0s0O/bsb8[:c]
/0s0O/BsB8[:c]
/0s0O/ese3[:c]
/0s0O/EsE3[:c]
/0s0O/isi1[:c]
/0s0O/isi![:c]
/0s0O/isi|[:c]
/0s0O/IsI1[:c]
/0s0O/IsI![:c]
/0s0O/IsI|[:c]
/0s0O/lsl1[:c]
/0s0O/lsl7[:c]
/0s0O/lsl|[:c]
/0s0O/lsl![:c]
/0s0O/Lsl1[:c]
/0s0O/Lsl7[:c]
/0s0O/Lsl|[:c]
/0s0O/Lsl![:c]
/0s0O/oso0[:c]
/0s0O/OsO0[:c]
/0s0O/sss$[:c]
/0s0O/sss5[:c]
/0s0O/SsS$[:c]
/0s0O/SsS5[:c]
/0s0O/tst+[:c]
/0s0O/TsT+[:c]
/0s0O/1s1![:c]
/0s0O/1s1i[:c]
/0s0O/1s1I[:c]
/0s0O/1s1|[:c]
/0s0O/3s3e[:c]
/0s0O/3s3E[:c]
/0s0O/4s4a[:c]
/0s0O/4s4A[:c]
/0s0O/5s5s[:c]
/0s0O/5s5S[:c]
/0s0O/7s7l[:c]
/0s0O/7s7L[:c]
/0s0O/8s8b[:c]
/0s0O/8s8B[:c]
/3s3e/asa@[:c]
/3s3e/asa4[:c]
/3s3e/AsA4[:c]
/3s3e/AsA@[:c]
/3s3e/bsb8[:c]
/3s3e/BsB8[:c]
/3s3e/ese3[:c]
/3s3e/EsE3[:c]
/3s3e/isi1[:c]
/3s3e/isi![:c]
/3s3e/isi|[:c]
/3s3e/IsI1[:c]
/3s3e/IsI![:c]
/3s3e/IsI|[:c]
/3s3e/lsl1[:c]
/3s3e/lsl7[:c]
/3s3e/lsl|[:c]
/3s3e/lsl![:c]
/3s3e/Lsl1[:c]
/3s3e/Lsl7[:c]
/3s3e/Lsl|[:c]
/3s3e/Lsl![:c]
/3s3e/oso0[:c]
/3s3e/OsO0[:c]
/3s3e/sss$[:c]
/3s3e/sss5[:c]
/3s3e/SsS$[:c]
/3s3e/SsS5[:c]
/3s3e/tst+[:c]
/3s3e/TsT+[:c]
/3s3e/1s1![:c]
/3s3e/1s1i[:c]
/3s3e/1s1I[:c]
/3s3e/1s1|[:c]
/3s3e/0s0o[:c]
/3s3e/0s0O[:c]
/3s3e/4s4a[:c]
/3s3e/4s4A[:c]
/3s3e/5s5s[:c]
/3s3e/5s5S[:c]
/3s3e/7s7l[:c]
/3s3e/7s7L[:c]
/3s3e/8s8b[:c]
/3s3e/8s8B[:c]
/3s3E/asa@[:c]
/3s3E/asa4[:c]
/3s3E/AsA4[:c]
/3s3E/AsA@[:c]
/3s3E/bsb8[:c]
/3s3E/BsB8[:c]
/3s3E/ese3[:c]
/3s3E/EsE3[:c]
/3s3E/isi1[:c]
/3s3E/isi![:c]
/3s3E/isi|[:c]
/3s3E/IsI1[:c]
/3s3E/IsI![:c]
/3s3E/IsI|[:c]
/3s3E/lsl1[:c]
/3s3E/lsl7[:c]
/3s3E/lsl|[:c]
/3s3E/lsl![:c]
/3s3E/Lsl1[:c]
/3s3E/Lsl7[:c]
/3s3E/Lsl|[:c]
/3s3E/Lsl![:c]
/3s3E/oso0[:c]
/3s3E/OsO0[:c]
/3s3E/sss$[:c]
/3s3E/sss5[:c]
/3s3E/SsS$[:c]
/3s3E/SsS5[:c]
/3s3E/tst+[:c]
/3s3E/TsT+[:c]
/3s3E/1s1![:c]
/3s3E/1s1i[:c]
/3s3E/1s1I[:c]
/3s3E/1s1|[:c]
/3s3E/0s0o[:c]
/3s3E/0s0O[:c]
/3s3E/4s4a[:c]
/3s3E/4s4A[:c]
/3s3E/5s5s[:c]
/3s3E/5s5S[:c]
/3s3E/7s7l[:c]
/3s3E/7s7L[:c]
/3s3E/8s8b[:c]
/3s3E/8s8B[:c]
/4s4a/asa@[:c]
/4s4a/asa4[:c]
/4s4a/AsA4[:c]
/4s4a/AsA@[:c]
/4s4a/bsb8[:c]
/4s4a/BsB8[:c]
/4s4a/ese3[:c]
/4s4a/EsE3[:c]
/4s4a/isi1[:c]
/4s4a/isi![:c]
/4s4a/isi|[:c]
/4s4a/IsI1[:c]
/4s4a/IsI![:c]
/4s4a/IsI|[:c]
/4s4a/lsl1[:c]
/4s4a/lsl7[:c]
/4s4a/lsl|[:c]
/4s4a/lsl![:c]
/4s4a/Lsl1[:c]
/4s4a/Lsl7[:c]
/4s4a/Lsl|[:c]
/4s4a/Lsl![:c]
/4s4a/oso0[:c]
/4s4a/OsO0[:c]
/4s4a/sss$[:c]
/4s4a/sss5[:c]
/4s4a/SsS$[:c]
/4s4a/SsS5[:c]
/4s4a/tst+[:c]
/4s4a/TsT+[:c]
/4s4a/1s1![:c]
/4s4a/1s1i[:c]
/4s4a/1s1I[:c]
/4s4a/1s1|[:c]
/4s4a/0s0o[:c]
/4s4a/0s0O[:c]
/4s4a/3s3e[:c]
/4s4a/3s3E[:c]
/4s4a/5s5s[:c]
/4s4a/5s5S[:c]
/4s4a/7s7l[:c]
/4s4a/7s7L[:c]
/4s4a/8s8b[:c]
/4s4a/8s8B[:c]
/4s4A/asa@[:c]
/4s4A/asa4[:c]
/4s4A/AsA4[:c]
/4s4A/AsA@[:c]
/4s4A/bsb8[:c]
/4s4A/BsB8[:c]
/4s4A/ese3[:c]
/4s4A/EsE3[:c]
/4s4A/isi1[:c]
/4s4A/isi![:c]
/4s4A/isi|[:c]
/4s4A/IsI1[:c]
/4s4A/IsI![:c]
/4s4A/IsI|[:c]
/4s4A/lsl1[:c]
/4s4A/lsl7[:c]
/4s4A/lsl|[:c]
/4s4A/lsl![:c]
/4s4A/Lsl1[:c]
/4s4A/Lsl7[:c]
/4s4A/Lsl|[:c]
/4s4A/Lsl![:c]
/4s4A/oso0[:c]
/4s4A/OsO0[:c]
/4s4A/sss$[:c]
/4s4A/sss5[:c]
/4s4A/SsS$[:c]
/4s4A/SsS5[:c]
/4s4A/tst+[:c]
/4s4A/TsT+[:c]
/4s4A/1s1![:c]
/4s4A/1s1i[:c]
/4s4A/1s1I[:c]
/4s4A/1s1|[:c]
/4s4A/0s0o[:c]
/4s4A/0s0O[:c]
/4s4A/3s3e[:c]
/4s4A/3s3E[:c]
/4s4A/5s5s[:c]
/4s4A/5s5S[:c]
/4s4A/7s7l[:c]
/4s4A/7s7L[:c]
/4s4A/8s8b[:c]
/4s4A/8s8B[:c]
/5s5s/asa@[:c]
/5s5s/asa4[:c]
/5s5s/AsA4[:c]
/5s5s/AsA@[:c]
/5s5s/bsb8[:c]
/5s5s/BsB8[:c]
/5s5s/ese3[:c]
/5s5s/EsE3[:c]
/5s5s/isi1[:c]
/5s5s/isi![:c]
/5s5s/isi|[:c]
/5s5s/IsI1[:c]
/5s5s/IsI![:c]
/5s5s/IsI|[:c]
/5s5s/lsl1[:c]
/5s5s/lsl7[:c]
/5s5s/lsl|[:c]
/5s5s/lsl![:c]
/5s5s/Lsl1[:c]
/5s5s/Lsl7[:c]
/5s5s/Lsl|[:c]
/5s5s/Lsl![:c]
/5s5s/oso0[:c]
/5s5s/OsO0[:c]
/5s5s/sss$[:c]
/5s5s/sss5[:c]
/5s5s/SsS$[:c]
/5s5s/SsS5[:c]
/5s5s/tst+[:c]
/5s5s/TsT+[:c]
/5s5s/1s1![:c]
/5s5s/1s1i[:c]
/5s5s/1s1I[:c]
/5s5s/1s1|[:c]
/5s5s/0s0o[:c]
/5s5s/0s0O[:c]
/5s5s/3s3e[:c]
/5s5s/3s3E[:c]
/5s5s/4s4a[:c]
/5s5s/4s4A[:c]
/5s5s/7s7l[:c]
/5s5s/7s7L[:c]
/5s5s/8s8b[:c]
/5s5s/8s8B[:c]
/5s5S/asa@[:c]
/5s5S/asa4[:c]
/5s5S/AsA4[:c]
/5s5S/AsA@[:c]
/5s5S/bsb8[:c]
/5s5S/BsB8[:c]
/5s5S/ese3[:c]
/5s5S/EsE3[:c]
/5s5S/isi1[:c]
/5s5S/isi![:c]
/5s5S/isi|[:c]
/5s5S/IsI1[:c]
/5s5S/IsI![:c]
/5s5S/IsI|[:c]
/5s5S/lsl1[:c]
/5s5S/lsl7[:c]
/5s5S/lsl|[:c]
/5s5S/lsl![:c]
/5s5S/Lsl1[:c]
/5s5S/Lsl7[:c]
/5s5S/Lsl|[:c]
/5s5S/Lsl![:c]
/5s5S/oso0[:c]
/5s5S/OsO0[:c]
/5s5S/sss$[:c]
/5s5S/sss5[:c]
/5s5S/SsS$[:c]
/5s5S/SsS5[:c]
/5s5S/tst+[:c]
/5s5S/TsT+[:c]
/5s5S/1s1![:c]
/5s5S/1s1i[:c]
/5s5S/1s1I[:c]
/5s5S/1s1|[:c]
/5s5S/0s0o[:c]
/5s5S/0s0O[:c]
/5s5S/3s3e[:c]
/5s5S/3s3E[:c]
/5s5S/4s4a[:c]
/5s5S/4s4A[:c]
/5s5S/7s7l[:c]
/5s5S/7s7L[:c]
/5s5S/8s8b[:c]
/5s5S/8s8B[:c]
/7s7l/asa@[:c]
/7s7l/asa4[:c]
/7s7l/AsA4[:c]
/7s7l/AsA@[:c]
/7s7l/bsb8[:c]
/7s7l/BsB8[:c]
/7s7l/ese3[:c]
/7s7l/EsE3[:c]
/7s7l/isi1[:c]
/7s7l/isi![:c]
/7s7l/isi|[:c]
/7s7l/IsI1[:c]
/7s7l/IsI![:c]
/7s7l/IsI|[:c]
/7s7l/lsl1[:c]
/7s7l/lsl7[:c]
/7s7l/lsl|[:c]
/7s7l/lsl![:c]
/7s7l/Lsl1[:c]
/7s7l/Lsl7[:c]
/7s7l/Lsl|[:c]
/7s7l/Lsl![:c]
/7s7l/oso0[:c]
/7s7l/OsO0[:c]
/7s7l/sss$[:c]
/7s7l/sss5[:c]
/7s7l/SsS$[:c]
/7s7l/SsS5[:c]
/7s7l/tst+[:c]
/7s7l/TsT+[:c]
/7s7l/1s1![:c]
/7s7l/1s1i[:c]
/7s7l/1s1I[:c]
/7s7l/1s1|[:c]
/7s7l/0s0o[:c]
/7s7l/0s0O[:c]
/7s7l/3s3e[:c]
/7s7l/3s3E[:c]
/7s7l/4s4a[:c]
/7s7l/4s4A[:c]
/7s7l/5s5s[:c]
/7s7l/5s5S[:c]
/7s7l/8s8b[:c]
/7s7l/8s8B[:c]
/7s7L/asa@[:c]
/7s7L/asa4[:c]
/7s7L/AsA4[:c]
/7s7L/AsA@[:c]
/7s7L/bsb8[:c]
/7s7L/BsB8[:c]
/7s7L/ese3[:c]
/7s7L/EsE3[:c]
/7s7L/isi1[:c]
/7s7L/isi![:c]
/7s7L/isi|[:c]
/7s7L/IsI1[:c]
/7s7L/IsI![:c]
/7s7L/IsI|[:c]
/7s7L/lsl1[:c]
/7s7L/lsl7[:c]
/7s7L/lsl|[:c]
/7s7L/lsl![:c]
/7s7L/Lsl1[:c]
/7s7L/Lsl7[:c]
/7s7L/Lsl|[:c]
/7s7L/Lsl![:c]
/7s7L/oso0[:c]
/7s7L/OsO0[:c]
/7s7L/sss$[:c]
/7s7L/sss5[:c]
/7s7L/SsS$[:c]
/7s7L/SsS5[:c]
/7s7L/tst+[:c]
/7s7L/TsT+[:c]
/7s7L/1s1![:c]
/7s7L/1s1i[:c]
/7s7L/1s1I[:c]
/7s7L/1s1|[:c]
/7s7L/0s0o[:c]
/7s7L/0s0O[:c]
/7s7L/3s3e[:c]
/7s7L/3s3E[:c]
/7s7L/4s4a[:c]
/7s7L/4s4A[:c]
/7s7L/5s5s[:c]
/7s7L/5s5S[:c]
/7s7L/8s8b[:c]
/7s7L/8s8B[:c]
/8s8b/asa@[:c]
/8s8b/asa4[:c]
/8s8b/AsA4[:c]
/8s8b/AsA@[:c]
/8s8b/bsb8[:c]
/8s8b/BsB8[:c]
/8s8b/ese3[:c]
/8s8b/EsE3[:c]
/8s8b/isi1[:c]
/8s8b/isi![:c]
/8s8b/isi|[:c]
/8s8b/IsI1[:c]
/8s8b/IsI![:c]
/8s8b/IsI|[:c]
/8s8b/lsl1[:c]
/8s8b/lsl7[:c]
/8s8b/lsl|[:c]
/8s8b/lsl![:c]
/8s8b/Lsl1[:c]
/8s8b/Lsl7[:c]
/8s8b/Lsl|[:c]
/8s8b/Lsl![:c]
/8s8b/oso0[:c]
/8s8b/OsO0[:c]
/8s8b/sss$[:c]
/8s8b/sss5[:c]
/8s8b/SsS$[:c]
/8s8b/SsS5[:c]
/8s8b/tst+[:c]
/8s8b/TsT+[:c]
/8s8b/1s1![:c]
/8s8b/1s1i[:c]
/8s8b/1s1I[:c]
/8s8b/1s1|[:c]
/8s8b/0s0o[:c]
/8s8b/0s0O[:c]
/8s8b/3s3e[:c]
/8s8b/3s3E[:c]
/8s8b/4s4a[:c]
/8s8b/4s4A[:c]
/8s8b/5s5s[:c]
/8s8b/5s5S[:c]
/8s8b/7s7l[:c]
/8s8b/7s7L[:c]
/8s8B/asa@[:c]
/8s8B/asa4[:c]
/8s8B/AsA4[:c]
/8s8B/AsA@[:c]
/8s8B/bsb8[:c]
/8s8B/BsB8[:c]
/8s8B/ese3[:c]
/8s8B/EsE3[:c]
/8s8B/isi1[:c]
/8s8B/isi![:c]
/8s8B/isi|[:c]
/8s8B/IsI1[:c]
/8s8B/IsI![:c]
/8s8B/IsI|[:c]
/8s8B/lsl1[:c]
/8s8B/lsl7[:c]
/8s8B/lsl|[:c]
/8s8B/lsl![:c]
/8s8B/Lsl1[:c]
/8s8B/Lsl7[:c]
/8s8B/Lsl|[:c]
/8s8B/Lsl![:c]
/8s8B/oso0[:c]
/8s8B/OsO0[:c]
/8s8B/sss$[:c]
/8s8B/sss5[:c]
/8s8B/SsS$[:c]
/8s8B/SsS5[:c]
/8s8B/tst+[:c]
/8s8B/TsT+[:c]
/8s8B/1s1![:c]
/8s8B/1s1i[:c]
/8s8B/1s1I[:c]
/8s8B/1s1|[:c]
/8s8B/0s0o[:c]
/8s8B/0s0O[:c]
/8s8B/3s3e[:c]
/8s8B/3s3E[:c]
/8s8B/4s4a[:c]
/8s8B/4s4A[:c]
/8s8B/5s5s[:c]
/8s8B/5s5S[:c]
/8s8B/7s7l[:c]
/8s8B/7s7L[:c]
# These are some popular triple/quad l33t rules
/asa4/ese3/lsl1[:c]
/asa4/ese3/oso0[:c]
/asa4/ese3/sss$[:c]
/asa4/lsl1/oso0[:c]
/asa4/lsl1/sss$[:c]
/asa4/oso0/sss$[:c]
/ese3/lsl1/oso0[:c]
/ese3/lsl1/sss$[:c]
/ese3/oso0/sss$[:c]
/lsl1/oso0/sss$[:c]
/asa4/ese3/lsl1/oso0[:c]
/asa4/ese3/lsl1/sss$[:c]
/asa4/ese3/oso0/sss$[:c]
/asa4/lsl1/oso0/sss$[:c]
/ese3/lsl1/oso0/sss$[:c]
/asa4/ese3/lsl1/oso0/sss$[:c]




# Case toggler for cracking MD4-based NTLM hashes (with the contributed patch)
# given already cracked DES-based LM hashes.
# Rename this section to [List.Rules:Wordlist] to activate it.
[List.Rules:NT]
:
-c T0Q
-c T1QT[z0]
-c T2QT[z0]T[z1]
-c T3QT[z0]T[z1]T[z2]
-c T4QT[z0]T[z1]T[z2]T[z3]
-c T5QT[z0]T[z1]T[z2]T[z3]T[z4]
-c T6QT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]
-c T7QT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]T[z6]
-c T8QT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]T[z6]T[z7]
-c T9QT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]T[z6]T[z7]T[z8]
-c TAQT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]T[z6]T[z7]T[z8]T[z9]
-c TBQT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]T[z6]T[z7]T[z8]T[z9]T[zA]
-c TCQT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]T[z6]T[z7]T[z8]T[z9]T[zA]T[zB]
-c TDQT[z0]T[z1]T[z2]T[z3]T[z4]T[z5]T[z6]T[z7]T[z8]T[z9]T[zA]T[zB]T[zC]

# Incremental modes
[Incremental:All]
File = $JOHN/all.chr
MinLen = 0
MaxLen = 8
CharCount = 95


[Incremental:All4]
File = $JOHN/all.chr
MinLen = 0
MaxLen = 4
CharCount = 95

[Incremental:Alpha]
File = $JOHN/alpha.chr
MinLen = 1
MaxLen = 8
CharCount = 26

[Incremental:Digits]
File = $JOHN/digits.chr
MinLen = 1
MaxLen = 8
CharCount = 10

[Incremental:Digits5]
File = $JOHN/digits.chr
MinLen = 1
MaxLen = 5
CharCount = 10

[Incremental:Alnum]
File = $JOHN/alnum.chr
MinLen = 1
MaxLen = 8
CharCount = 36

[Incremental:LanMan]
File = $JOHN/lanman.chr
MinLen = 0
MaxLen = 7
CharCount = 69

# Some pre-defined word filters
[List.External:Filter_Alpha]
void filter()
{
	int i, c;

	i = 0;
	while (c = word[i++])
	if (c < 'a' || c > 'z') {
		word = 0; return;
	}
}

[List.External:Filter_Digits]
void filter()
{
	int i, c;

	i = 0;
	while (c = word[i++])
	if (c < '0' || c > '9') {
		word = 0; return;
	}
}

[List.External:Filter_Alnum]
void filter()
{
	int i, c;

	i = 0;
	while (c = word[i++])
	if ((c < 'a' || c > 'z') && (c < '0' || c > '9')) {
		word = 0; return;
	}
}

[List.External:Filter_No_Cap_or_Symbols]
void filter()
{
	int i, c;

	i = 0;
	while (c = word[i++])
	if ((c < 'a' || c > 'z') && (c < '0' || c > '9')) {
		return;
	}
	word = 0; return;
}

[List.External:Filter_LanMan]
void filter()
{
	int i, c;

	word[7] = 0;			// Truncate at 7 characters

	i = 0;				// Convert to uppercase
	while (c = word[i]) {
		if (c >= 'a' && c <= 'z') word[i] &= 0xDF;
		i++;
	}
}

# A simple cracker for LM hashes
[List.External:LanMan]
int length;				// Current length

void init()
{
	word[0] = 'A' - 1;		// Start with "A"
	word[length = 1] = 0;
}

void generate()
{
	int i;

	i = length - 1;			// Start from the last character
	while (++word[i] > 'Z')		// Try to increase it
	if (i)				// Overflow here, any more positions?
		word[i--] = 'A';	// Yes, move to the left, and repeat
	else				// No
	if (length < 7) {
		word[i = ++length] = 0;	// Switch to the next length
		while (i--)
			word[i] = 'A';
		return;
	} else {
		word = 0; return;	// We're done
	}
}

void restore()
{
	length = 0;			// Calculate the length
	while (word[length]) length++;
}

# Simple and well-commented, yet useful external mode example
[List.External:Double]
/*
 * This cracking mode tries all the possible duplicated lowercase alphabetic
 * "words" of up to 8 characters long.  Since word halves are the same, it
 * only has to try about 500,000 words.
 */

/* Global variables: current length and word */
int length, current[9];

/* Called at startup to initialize the global variables */
void init()
{
	int i;

	i = length = 2;			// Start with 4 character long words
	while (i--) current[i] = 'a';	// Set our half-word to "aa"
}

/* Generates a new word */
void generate()
{
	int i;

/* Export last generated word, duplicating it at the same time; here "word"
 * is a pre-defined external variable. */
	word[(i = length) << 1] = 0;
	while (i--) word[length + i] = word[i] = current[i];

/* Generate a new word */
	i = length - 1;			// Start from the last character
	while (++current[i] > 'z')	// Try to increase it
	if (i)				// Overflow here, any more positions?
		current[i--] = 'a';	// Yes, move to the left, and repeat
	else {				// No
		current = 0;		// Request a length switch
		break;			// Break out of the loop
	}

/* Switch to the next length, unless we were generating 8 character long
 * words already. */
	if (!current && length < 4) {
		i = ++length;
		while (i--) current[i] = 'a';
	}
}

/* Called when restoring an interrupted session */
void restore()
{
	int i;

/* Import the word back */
	i = 0;
	while (current[i] = word[i]) i++;

/* ...and calculate the half-word length */
	length = i >> 1;
}

# Trivial parallel processing example
[List.External:Parallel]
/*
 * This word filter makes John process some of the words only, for running
 * multiple instances on different CPUs.  It can be used with any cracking
 * mode except for "single crack".  Note: this is not a good solution, but
 * is just an example of what can be done with word filters.
 */

int node, total;			// This node's number, and node count
int number;				// Current word number

void init()
{
	node = 1; total = 2;		// Node 1 of 2, change as appropriate
	number = node - 1;		// Speedup the filter a bit
}

void filter()
{
	if (number++ % total)		// Word for a different node?
		word = 0;		// Yes, skip it
}

# Strip 0.5 ("Secure Tool for Recalling Important Passwords") cracker,
# based on analysis done by Thomas Roessler and Ian Goldberg.  This will
# crack passwords you may have generated with Strip; other uses of Strip
# are unaffected.
[List.External:Strip]
int minlength, maxlength, mintype, maxtype;
int crack_seed, length, type;
int count, charset[128];

void init()
{
	int c;

/* Password lengths to try; Strip can generate passwords of 4 to 16
 * characters, but traditional crypt(3) hashes are limited to 8. */
	minlength = 4;	// 4
	maxlength = 8;	// 16

/* Password types to try (Numeric, Alpha-Num, Alpha-Num w/ Meta). */
	mintype = 0;	// 0
	maxtype = 2;	// 2

	crack_seed = 0x10000;
	length = minlength - 1;
	type = mintype;

	count = 0;
	c = '0'; while (c <= '9') charset[count++] = c++;
}

void generate()
{
	int seed, random;
	int i, c;

	if (crack_seed > 0xffff) {
		crack_seed = 0;

		if (++length > maxlength) {
			length = minlength;

			if (++type > maxtype) {
				word[0] = 0;
				return;
			}
		}

		count = 10;
		if (type >= 1) {
			c = 'a'; while (c <= 'f') charset[count++] = c++;
			c = 'h'; while (c <= 'z') charset[count++] = c++;
			c = 'A'; while (c <= 'Z') charset[count++] = c++;
		}
		if (type == 2) {
			charset[count++] = '!';
			c = '#'; while (c <= '&') charset[count++] = c++;
			c = '('; while (c <= '/') charset[count++] = c++;
			c = '<'; while (c <= '>') charset[count++] = c++;
			charset[count++] = '?'; charset[count++] = '@';
			charset[count++] = '['; charset[count++] = ']';
			charset[count++] = '^'; charset[count++] = '_';
			c = '{'; while (c <= '~') charset[count++] = c++;
		}
	}

	seed = (crack_seed++ << 16 >> 16) * 22695477 + 1;

	i = 0;
	while (i < length) {
		random = ((seed = seed * 22695477 + 1) >> 16) & 0x7fff;
		word[i++] = charset[random % count];
	}

	word[i] = 0;
}

# Try sequences of adjacent keys on a keyboard as candidate passwords
[List.External:Keyboard]
int maxlength, length;	// Maximum password length to try, current length
int fuzz;		// The desired "fuzz factor", either 0 or 1
int id[15];		// Current character indices for each position
int m[0x400], mc[0x80];	// The keys matrix, counts of adjacent keys
int f[0x40], fc;	// Characters for the first position, their count

void init()
{
	int minlength;
	int i, j, c, p;
	int k[0x40];

	minlength = 1;	// Initial password length to try
	maxlength = 15;	// Maximum password length to try, up to 15
	fuzz = 1;	// "Fuzz factor", set to 0 for much quicker runs

/*
 * This defines the keyboard layout, by default for a QWERTY keyboard.
 * Please note that the sizes of m[] and mc[] arrays assume 7-bit
 * characters and will need to be doubled for 8-bit characters such as
 * umlauts.
 */
	i = 0; while (i < 0x40) k[i++] = 0;
	k[0] = '`';
	i = 0; while (++i <= 9) k[i] = '0' + i;
	k[10] = '0'; k[11] = '-'; k[12] = '=';
	k[0x11] = 'q'; k[0x12] = 'w'; k[0x13] = 'e'; k[0x14] = 'r';
	k[0x15] = 't'; k[0x16] = 'y'; k[0x17] = 'u'; k[0x18] = 'i';
	k[0x19] = 'o'; k[0x1a] = 'p'; k[0x1b] = '['; k[0x1c] = ']';
	k[0x1d] = '\\';
	k[0x21] = 'a'; k[0x22] = 's'; k[0x23] = 'd'; k[0x24] = 'f';
	k[0x25] = 'g'; k[0x26] = 'h'; k[0x27] = 'j'; k[0x28] = 'k';
	k[0x29] = 'l'; k[0x2a] = ';'; k[0x2b] = '\'';
	k[0x31] = 'z'; k[0x32] = 'x'; k[0x33] = 'c'; k[0x34] = 'v';
	k[0x35] = 'b'; k[0x36] = 'n'; k[0x37] = 'm'; k[0x38] = ',';
	k[0x39] = '.'; k[0x3a] = '/';

	i = 0; while (i < 0x80) mc[i++] = 0;
	fc = 0;

	/* rows */
	c = 0;
	i = 0;
	while (i < 0x40) {
		p = c;
		c = k[i++];
		if (!c) continue;
		f[fc++] = c;
		if (!p) continue;
		m[(c << 3) + mc[c]++] = p;
		m[(p << 3) + mc[p]++] = c;
	}
	f[fc] = 0;

	/* columns */
	i = 0;
	while (i < 0x30) {
		p = k[i++];
		if (!p) continue;
		j = 1 - fuzz;
		while (j <= 1 + fuzz) {
			c = k[i + 0x10 - j++];
			if (!c) continue;
			m[(c << 3) + mc[c]++] = p;
			m[(p << 3) + mc[p]++] = c;
		}
	}

	id[0] = 0;
	length = minlength;
}

void generate()
{
	int i, p, maxcount;

	word[i = 0] = p = f[id[0]];
	while (++i < length)
		word[i] = p = m[(p << 3) + id[i]];
	word[i--] = 0;

	if (i) maxcount = mc[word[i - 1]]; else maxcount = fc;
	while (++id[i] >= maxcount) {
		if (!i) {
			if (length < maxlength) {
				id[0] = 0;
				id[length++] = 0;
			}
			return;
		}
		id[i--] = 0;
		if (i) maxcount = mc[word[i - 1]]; else maxcount = fc;
	}
}

void restore()
{
	int i;

	/* Calculate the length */
	length = 0;
	while (word[length]) length++;

	/* Infer the first character index */
	i = -1;
	while (++i < fc) {
		if (f[i] == word[0]) {
			id[0] = i;
			break;
		}
	}

	/* This sample can be enhanced to infer the rest of the indices here */
}

# Generic implementation of "dumb" exhaustive search, given a range of lengths
# and an arbitrary charset.  This is pre-configured to try 8-bit characters
# against LM hashes, which is only reasonable to do for very short password
# half lengths.
[List.External:DumbForce]
int maxlength;		// Maximum password length to try
int last;		// Last character position, zero-based
int lastid;		// Character index in the last position
int id[0x7f];		// Current character indices for other positions
int charset[0x100], c0;	// Character set

void init()
{
	int minlength;
	int i, c;

	minlength = 1;	// Initial password length to try, must be at least 1
	maxlength = 7;	// Must be at least same as minlength

/*
 * This defines the character set.
 *
 * Let's say, we want to try TAB, all non-control ASCII characters, and all
 * 8-bit characters, including the 8-bit terminal controls range (as these are
 * used as regular national characters with some 8-bit encodings), but except
 * for known terminal controls (risky for the terminal we may be running on).
 *
 * Also, let's say our hashes are case-insensitive, so skip lowercase letters
 * (this is right for LM hashes).
 */
	i = 0;
	charset[i++] = 9;		// Add horizontal TAB (ASCII 9), then
	c = ' ';			// start with space (ASCII 32) and
	while (c < 'a')			// proceed till lowercase 'a'
		charset[i++] = c++;
	c = 'z' + 1;			// Skip lowercase letters and
	while (c <= 0x7e)		// proceed for all printable ASCII
		charset[i++] = c++;
	c++;				// Skip DEL (ASCII 127) and
	while (c < 0x84)		// proceed over 8-bit codes till IND
		charset[i++] = c++;
	charset[i++] = 0x86;		// Skip IND (84 hex) and NEL (85 hex)
	charset[i++] = 0x87;
	c = 0x89;			// Skip HTS (88 hex)
	while (c < 0x8d)		// Proceed till RI (8D hex)
		charset[i++] = c++;
	c = 0x91;			// Skip RI, SS2, SS3, DCS
	while (c < 0x96)		// Proceed till SPA (96 hex)
		charset[i++] = c++;
	charset[i++] = 0x99;		// Skip SPA, EPA, SOS
	c = 0xa0;			// Skip DECID, CSI, ST, OSC, PM, APC
	while (c <= 0xff)		// Proceed with the rest of 8-bit codes
		charset[i++] = c++;

/* Zero-terminate it, and cache the first character */
	charset[i] = 0;
	c0 = charset[0];

	last = minlength - 1;
	i = 0;
	while (i <= last) {
		id[i] = 0;
		word[i++] = c0;
	}
	lastid = -1;
	word[i] = 0;
}

void generate()
{
	int i;

/* Handle the typical case specially */
	if (word[last] = charset[++lastid]) return;

	lastid = 0;
	word[i = last] = c0;
	while (i--) {			// Have a preceding position?
		if (word[i] = charset[++id[i]]) return;
		id[i] = 0;
		word[i] = c0;
	}

	if (++last < maxlength) {	// Next length?
		id[last] = lastid = 0;
		word[last] = c0;
		word[last + 1] = 0;
	} else				// We're done
		word = 0;
}

void restore()
{
	int i, c;

/* Calculate the current length and infer the character indices */
	last = 0;
	while (c = word[last]) {
		i = 0; while (charset[i] != c && charset[i]) i++;
		if (!charset[i]) i = 0;	// Not found
		id[last++] = i;
	}
	lastid = id[--last];
}

# Generic implementation of exhaustive search for a partially-known password.
# This is pre-configured for length 8, lowercase and uppercase letters in the
# first 4 positions (52 different characters), and digits in the remaining 4
# positions - however, the corresponding part of init() may be modified to use
# arbitrary character sets or even fixed characters for each position.
[List.External:KnownForce]
int last;		// Last character position, zero-based
int lastofs;		// Last character position offset into charset[]
int lastid;		// Current character index in the last position
int id[0x7f];		// Current character indices for other positions
int charset[0x7f00];	// Character sets, 0x100 elements for each position

void init()
{
	int length;
	int pos, ofs, i, c;

	length = 8;	// Password length to try

/* This defines the character sets for different character positions */
	pos = 0;
	while (pos < 4) {
		ofs = pos++ << 8;
		i = 0;
		c = 'a';
		while (c <= 'z')
			charset[ofs + i++] = c++;
		c = 'A';
		while (c <= 'Z')
			charset[ofs + i++] = c++;
		charset[ofs + i] = 0;
	}
	while (pos < length) {
		ofs = pos++ << 8;
		i = 0;
		c = '0';
		while (c <= '9')
			charset[ofs + i++] = c++;
		charset[ofs + i] = 0;
	}

	last = length - 1;
	pos = -1;
	while (++pos <= last)
		word[pos] = charset[id[pos] = pos << 8];
	lastid = (lastofs = last << 8) - 1;
	word[pos] = 0;
}

void generate()
{
	int pos;

/* Handle the typical case specially */
	if (word[last] = charset[++lastid]) return;

	word[pos = last] = charset[lastid = lastofs];
	while (pos--) {			// Have a preceding position?
		if (word[pos] = charset[++id[pos]]) return;
		word[pos] = charset[id[pos] = pos << 8];
	}

	word = 0;			// We're done
}

void restore()
{
	int i, c;

/* Calculate the current length and infer the character indices */
	last = 0;
	while (c = word[last]) {
		i = lastofs = last << 8;
		while (charset[i] != c && charset[i]) i++;
		if (!charset[i]) i = lastofs; // Not found
		id[last++] = i;
	}
	lastid = id[--last];
}

# A variation of KnownForce configured to try likely date and time strings.
[List.External:DateTime]
int last;		// Last character position, zero-based
int lastofs;		// Last character position offset into charset[]
int lastid;		// Current character index in the last position
int id[0x7f];		// Current character indices for other positions
int charset[0x7f00];	// Character sets, 0x100 elements for each position

void init()
{
	int length;
	int pos, ofs, i, c;

	length = 8;	// Must be one of: 4, 5, 7, 8

/* This defines the character sets for different character positions */
	pos = 0;
	while (pos < length - 6) {
		ofs = pos++ << 8;
		i = 0;
		c = '0';
		while (c <= '9')
			charset[ofs + i++] = c++;
		charset[ofs + i] = 0;
	}
	if (pos) {
		ofs = pos++ << 8;
		charset[ofs] = '/';
		charset[ofs + 1] = '.';
		charset[ofs + 2] = ':';
		charset[ofs + 3] = 0;
	}
	while (pos < length - 3) {
		ofs = pos++ << 8;
		i = 0;
		c = '0';
		while (c <= '9')
			charset[ofs + i++] = c++;
		charset[ofs + i] = 0;
	}
	ofs = pos++ << 8;
	charset[ofs] = '/';
	charset[ofs + 1] = '.';
	charset[ofs + 2] = ':';
	charset[ofs + 3] = 0;
	while (pos < length) {
		ofs = pos++ << 8;
		i = 0;
		c = '0';
		while (c <= '9')
			charset[ofs + i++] = c++;
		charset[ofs + i] = 0;
	}

	last = length - 1;
	pos = -1;
	while (++pos <= last)
		word[pos] = charset[id[pos] = pos << 8];
	lastid = (lastofs = last << 8) - 1;
	word[pos] = 0;
}

void generate()
{
	int pos;

/* Handle the typical case specially */
	if (word[last] = charset[++lastid]) return;

	word[pos = last] = charset[lastid = lastofs];
	while (pos--) {			// Have a preceding position?
		if (word[pos] = charset[++id[pos]]) return;
		word[pos] = charset[id[pos] = pos << 8];
	}

	word = 0;			// We're done
}

void restore()
{
	int i, c;

/* Calculate the current length and infer the character indices */
	last = 0;
	while (c = word[last]) {
		i = lastofs = last << 8;
		while (charset[i] != c && charset[i]) i++;
		if (!charset[i]) i = lastofs; // Not found
		id[last++] = i;
	}
	lastid = id[--last];
}

# Try strings of repeated characters.
[List.External:Repeats]
int minlength, maxlength, minc, maxc, length, c;

void init()
{
	minlength = 1;
	maxlength = 72;
	minc = 0x20;
	maxc = 0xff;

	length = minlength; c = minc;
}

void generate()
{
	int i;

	i = 0;
	while (i < length)
		word[i++] = c;
	word[i] = 0;

	if (c++ < maxc)
		return;

	c = minc;
	if (++length > maxlength)
		c = 0; // Will NUL out the next "word" and thus terminate
}

# Generate candidate passwords from many small subsets of characters from a
# much larger full character set.  This will test for passwords containing too
# few different characters.  As currently implemented, this code will produce
# some duplicates, although their number is relatively small when the maximum
# number of different characters (the maxdiff setting) is significantly lower
# than the maximum length (the maxlength setting).  Nevertheless, you may want
# to pass the resulting candidate passwords through "unique" if you intend to
# test them against hashes that are salted and/or of a slow to compute type.
[List.External:Subsets]
int minlength;		// Minimum password length to try
int maxlength;		// Maximum password length to try
int startdiff;		// Initial number of characters in a subset to try
int maxdiff;		// Maximum number of characters in a subset to try
int last;		// Last character position, zero-based
int lastid;		// Character index in the last position
int id[0x7f];		// Current character indices for other positions
int subset[0x100], c0;	// Current subset
int subcount;		// Number of characters in the current subset
int subid[0x100];	// Indices into charset[] of characters in subset[]
int charset[0x100];	// Full character set
int charcount;		// Number of characters in the full charset

void init()
{
	int i, c;

	minlength = 1;	// Minimum password length to try, must be at least 1
	maxlength = 8;	// Must be at least same as minlength

	startdiff = 1;	// Initial number of different characters to try
	maxdiff = 3;	// Maximum number of different characters to try

/* This defines the character set */
	i = 0;
	c = 0x20;
	while (c <= 0x7e)
		charset[i++] = c++;

	if (maxdiff > (charcount = i))
		maxdiff = i;
	if (maxdiff > maxlength)
		maxdiff = maxlength;

/*
 * Initialize the variables such that generate() gets to its "next subset"
 * code, which will initialize everything for real.
 */
	subcount = (i = startdiff) - 1;
	while (i--)
		subid[i] = charcount;
	subset[0] = c0 = 0;
	last = maxlength - 1;
	lastid = -1;
}

void generate()
{
	int i;

/* Handle the typical case specially */
	if (word[last] = subset[++lastid]) return;

	lastid = 0;
	word[i = last] = c0;
	while (i--) {			// Have a preceding position?
		if (word[i] = subset[++id[i]]) return;
		id[i] = 0;
		word[i] = c0;
	}

	if (++last < maxlength) {	// Next length?
		id[last] = lastid = 0;
		word[last] = c0;
		word[last + 1] = 0;
		return;
	}

/* Next subset */
	if (subcount) {
		int j;
		i = subcount - 1;
		j = charcount;
		while (++subid[i] >= j) {
			if (i--) {
				j--;
				continue;
			}
			subid[i = 0] = 0;
			subset[++subcount] = 0;
			break;
		}
	} else {
		subid[i = 0] = 0;
		subset[++subcount] = 0;
	}
	subset[i] = charset[subid[i]];
	while (++i < subcount)
		subset[i] = charset[subid[i] = subid[i - 1] + 1];

	if (subcount > maxdiff) {
		word = 0;		// Done
		return;
	}

/*
 * We won't be able to fully use the subset if the length is smaller than the
 * character count.  We assume that we've tried all smaller subsets before, so
 * we don't bother with such short lengths.
 */
	if (minlength < subcount)
		last = subcount - 1;
	else
		last = minlength - 1;
	c0 = subset[0];
	i = 0;
	while (i <= last) {
		id[i] = 0;
		word[i++] = c0;
	}
	lastid = 0;
	word[i] = 0;
}

# Simple password policy matching: require at least one digit.
[List.External:AtLeast1-Simple]
void filter()
{
	int i, c;

	i = 0;
	while (c = word[i++])
		if (c >= '0' && c <= '9')
			return; // Found at least one suitable character, good

	word = 0; // No suitable characters found, skip this "word"
}

# The same password policy implemented in a more efficient and more generic
# fashion (easy to expand to include other "sufficient" characters as well).
[List.External:AtLeast1-Generic]
int mask[0x100];

void init()
{
	int c;

	mask[0] = 0; // Terminate the loop in filter() on NUL
	c = 1;
	while (c < 0x100)
		mask[c++] = 1; // Continue looping in filter() on most chars

	c = '0';
	while (c <= '9')
		mask[c++] = 0; // Terminate the loop in filter() on digits
}

void filter()
{
	int i;

	i = -1;
	while (mask[word[++i]])
		continue;
	if (word[i])
		return; // Found at least one suitable character, good

	word = 0; // No suitable characters found, skip this "word"
}

# An efficient and fairly generic password policy matcher.  The policy to match
# is specified in the check at the end of filter() and in mask[].  For example,
# lowercase and uppercase letters may be treated the same by initializing the
# corresponding mask[] elements to the same value, then adjusting the value to
# check "seen" for accordingly.
[List.External:Policy]
int mask[0x100];

void init()
{
	int c;

	mask[0] = 0x100;
	c = 1;
	while (c < 0x100)
		mask[c++] = 0x200;

	c = 'a';
	while (c <= 'z')
		mask[c++] = 1;
	c = 'A';
	while (c <= 'Z')
		mask[c++] = 2;
	c = '0';
	while (c <= '9')
		mask[c++] = 4;
}

void filter()
{
	int i, seen;

/*
 * This loop ends when we see NUL (sets 0x100) or a disallowed character
 * (sets 0x200).
 */
	i = -1; seen = 0;
	while ((seen |= mask[word[++i]]) < 0x100)
		continue;

/*
 * We should have seen at least one character of each type (which "add up"
 * to 7) and then a NUL (adds 0x100), but not any other characters (would
 * add 0x200).  The length must be 8.
 */
	if (seen != 0x107 || i != 8)
		word = 0; // Does not conform to policy
}

# Append the Luhn algorithm digit to arbitrary all-digit strings.  Optimized
# for speed, not for size nor simplicity.  The primary optimization trick is to
# compute the length and four sums in parallel (in two SIMD'ish variables).
# Then whether the length is even or odd determines which two of the four sums
# are actually used.  Checks for non-digits and for NUL are packed into the
# SIMD'ish bitmasks as well.
[List.External:AppendLuhn]
int map1[0x100], map2[0x1fff];

void init()
{
	int i;

	map1[0] = ~0x7fffffff;
	i = 1;
	while (i < 0x100)
		map1[i++] = ~0x7effffff;
	i = -1;
	while (++i < 10)
		map1['0' + i] = i + ((i * 2 % 10 + i / 5) << 12);
	i = -1;
	while (++i < 0x1fff) {
		if (i % 10)
			map2[i] = '9' + 1 - i % 10;
		else
			map2[i] = '0';
	}
}

void filter()
{
	int i, o, e;

	i = o = e = 0;
	while ((o += map1[word[i++]]) >= 0) {
		if ((e += map1[word[i++]]) >= 0)
			continue;
		if (e & 0x01000000)
			return; // Not all-digit, leave unmodified
		word[i--] = 0;
		word[i] = map2[(e & 0xfff) + (o >> 12)];
		return;
	}
	if (o & 0x01000000)
		return; // Not all-digit, leave unmodified
	word[i--] = 0;
	word[i] = map2[(o & 0xfff) + (e >> 12)];
}

# Here are some examples of GENERIC-MD5.
# Please refer to doc/MD5_GENERIC for documentation on how to set these up.

####################################################################
# Simple GENERIC-MD5 type for md5($p)^^4  (i.e. 4 steps of md5 recursively)
####################################################################
[List.Generic:md5_gen(1001)]
# expression shown will be the string:   md5_gen(1001) md5(md5(md5(md5($p))))
Expression=md5(md5(md5(md5($p))))
Flag=MGF_KEYS_INPUT
# here is the optimized 'script' to perform the md5 4 times on itself.
Func=MD5GenBaseFunc__crypt
Func=MD5GenBaseFunc__clean_input2
Func=MD5GenBaseFunc__append_from_last_output_to_input2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt_in2_to_out1
Test=md5_gen(1001)57200e13b490d4ae47d5e19be026b057:test1
Test=md5_gen(1001)c6cc44f9e7fb7efcde62ba2e627a49c6:thatsworking
Test=md5_gen(1001)0ae9549604e539a249c1fa9f5e5fb73b:test3

####################################################################
# Simple GENERIC-MD5 type for md5($p)^^5  (i.e. 5 steps of md5 recursively)
####################################################################
[List.Generic:md5_gen(1002)]
# expression shown will be the string:   md5_gen(1002) md5(md5(md5(md5(md5($p)))))
Expression=md5(md5(md5(md5(md5($p)))))
Flag=MGF_KEYS_INPUT
# here is the optimized 'script' to perform the md5 5 times on itself.
Func=MD5GenBaseFunc__crypt
Func=MD5GenBaseFunc__clean_input2
Func=MD5GenBaseFunc__append_from_last_output_to_input2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt_in2_to_out1
# These are test strings for this format.
Test=md5_gen(1002)25de8cd0b0cf69c5b5bc19c8ee64adab:test1
Test=md5_gen(1002)a0b535420ea47849f7c2cc09a3ad0ac3:thatsworking
Test=md5_gen(1002)4cb029bd5b4ef79f785ca685caf17bf8:test3

####################################################################
# Simple GENERIC-MD5 type for md5(md5($p).md5($p))
####################################################################
[List.Generic:md5_gen(1003)]
# expression shown will be the string:   md5_gen(1003) md5(md5($p).md5($p))
Expression=md5(md5($p).md5($p))
# NOTE, this format does NOT work on SSE2.  It requires a md5() of a 64 byte string.
# SSE (or MMX) is limtited to 54 byte max password, due to 'enhancements'
# Thus, we need a non-sse2 safe flag.
Flag=MGF_NOTSSE2Safe
Flag=MGF_KEYS_INPUT
# here is the optimized 'script' to perform hash 'like' IPB but salt replaced with password.
Func=MD5GenBaseFunc__crypt
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output_to_input2_as_base16
Func=MD5GenBaseFunc__append_from_last_output_to_input2_as_base16
Func=MD5GenBaseFunc__crypt_in2_to_out1
# These are test strings for this format.
Test=md5_gen(1003)478b10974f15e7295883224fd286ccba:test1
Test=md5_gen(1003)18a59101e6c6fb38260d542a394ecb22:thatsworking
Test=md5_gen(1003)630b01b68b6db6fd43a751f8147d1faf:test3

####################################################################
# Simple GENERIC-MD5 type for md5($p)^^6  (i.e. 6 steps of md5 recursively)
####################################################################
[List.Generic:md5_gen(1004)]
# expression shown will be the string:   md5_gen(1004) md5(md5(md5(md5(md5(md5($p))))))
Expression=md5(md5(md5(md5(md5(md5($p))))))
Flag=MGF_KEYS_INPUT
# here is the optimized 'script' to perform the md5 6 times on itself.
Func=MD5GenBaseFunc__crypt
Func=MD5GenBaseFunc__clean_input2
Func=MD5GenBaseFunc__append_from_last_output_to_input2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt_in2_to_out1
# These are test strings for this format.
Test=md5_gen(1004)de1b991dd27fb9813e88b957a455dccd:test1
Test=md5_gen(1004)6a62cd3c4d81139f61fb2553cdef0dc7:thatsworking
Test=md5_gen(1004)a977990e521c5d1d17c6d65fdf2681b4:test3


####################################################################
# Simple GENERIC-MD5 type for md5($p)^^7  (i.e. 7 steps of md5 recursively)
####################################################################
[List.Generic:md5_gen(1005)]
# expression shown will be the string:   md5_gen(1005) md5(md5(md5(md5(md5(md5(md5($p)))))))
Expression=md5(md5(md5(md5(md5(md5(md5($p)))))))
Flag=MGF_KEYS_INPUT
# here is the optimized 'script' to perform the md5 7 times on itself.
Func=MD5GenBaseFunc__crypt
Func=MD5GenBaseFunc__clean_input2
Func=MD5GenBaseFunc__append_from_last_output_to_input2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt_in2_to_out1
# These are test strings for this format.
Test=md5_gen(1005)784c527d0d92873ff9c0773e1c35621d:test1
Test=md5_gen(1005)efcbbe6331caecf0e7f40160e65aadcc:thatsworking
Test=md5_gen(1005)abb8bdd2c6ac2dfea2b2af6f5aed5446:test3

####################################################################
# Simple GENERIC-MD5 type for md5($p)^^8  (i.e. 8 steps of md5 recursively)
####################################################################
[List.Generic:md5_gen(1006)]
# expression shown will be the string:   md5_gen(1006) md5(md5(md5(md5(md5(md5(md5(md5($p))))))))
Expression=md5(md5(md5(md5(md5(md5(md5(md5($p))))))))
Flag=MGF_KEYS_INPUT
# here is the optimized 'script' to perform the md5 8 times on itself.
Func=MD5GenBaseFunc__crypt
Func=MD5GenBaseFunc__clean_input2
Func=MD5GenBaseFunc__append_from_last_output_to_input2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt2
Func=MD5GenBaseFunc__clean_input2_kwik
Func=MD5GenBaseFunc__append_from_last_output2_as_base16
Func=MD5GenBaseFunc__crypt_in2_to_out1
# These are test strings for this format.
Test=md5_gen(1006)1ec1f32398f64cab51183f63630eceea:test1
Test=md5_gen(1006)f66b339ac21d6fd6af216f2b70aab2c9:thatsworking
Test=md5_gen(1006)e9d38522b5eeec753332e576e2e0fe5d:test3

####################################################################
# Simple GENERIC-MD5 type for vBulletin md5(md5($p).$s)   Included here to 'exercise' the script parser
####################################################################
[List.Generic:md5_gen(1007)]
# expression shown will be the string:   md5_gen(1007) md5(md5($p).$s) [vBulletin]
Expression=md5(md5($p).$s) [vBulletin]
# Flag needed here, is Salt.  There is no 'fixed' saltlen.
Flag=MGF_SALTED
Flag=MGF_ColonNOTValid
Flag=MGF_KEYS_BASE16_IN1
# vBulletin has a 'fixed' 3 byte salt, so list the fixed size
SaltLen=3
ColonChar=;
# here is the optimized 'script' to perform vBulletin hash
Func=MD5GenBaseFunc__set_input_len_32
Func=MD5GenBaseFunc__append_salt
Func=MD5GenBaseFunc__crypt
# NOTE, vBulletin is setup to 'override' the ':'.  USUALLY, it is good to use something
# outside of the ASCII values from 0x20 to 0x7F.  0x1F is a 'good' choice, but it will
# cause john.conf to have a 'non-normal' ASCII char.  Thus for this 'simple' example, I
# have used the ';' character.  NOTE this would have the same 'problems' as the ':' character
# if used for real, since ; is also a valid character within the salt of vBulletin.
# NOTE to run, you MUST use the command line switch:   -field-separator-char=;
Test=md5_gen(1007)daa61d77e218e42060c2fa198ac1feaf$SXB;test1
Test=md5_gen(1007)de56b00bb15d6db79204bd44383469bc$T &;thatsworking
Test=md5_gen(1007)fb685c6f469f6e549c85e4c1fb5a65a6$\\H:;test3

####################################################################
# Simple GENERIC-MD5 type for joomla md5($p.$s)   Included here to 'exercise' the script parser
####################################################################
[List.Generic:md5_gen(1008)]
# expression shown will be the string:   md5_gen(1008) md5($p.$s) [joomla]
Expression=md5($p.$s) [joomla]
# Flag needed here, is Salt.  There is no 'fixed' saltlen.
Flag=MGF_SALTED
# here is the optimized 'script' to perform the md5 8 times on itself.
Func=MD5GenBaseFunc__clean_input
Func=MD5GenBaseFunc__append_keys
Func=MD5GenBaseFunc__append_salt
Func=MD5GenBaseFunc__crypt
Test=md5_gen(1008)ed52af63d8ecf0c682442dfef5f36391$1aDNNojYGSc7pSzcdxKxhbqvLtEe4deG:test1
Test=md5_gen(1008)4fa1e9d54d89bfbe48b4c0f0ca0a3756$laxcaXPjgcdKdKEbkX1SIjHKm0gfYt1c:thatsworking
Test=md5_gen(1008)82568eeaa1fcf299662ccd59d8a12f54$BdWwFsbGtXPGc0H1TBxCrn0GasyAlJBJ:test3