(* Content-type: application/vnd.wolfram.mathematica *)

(*** Wolfram Notebook File ***)
(* http://www.wolfram.com/nb *)

(* CreatedBy='Wolfram 15.0' *)

(*CacheID: 234*)
(* Internal cache information:
NotebookFileLineBreakTest
NotebookFileLineBreakTest
NotebookDataPosition[       154,          7]
NotebookDataLength[     79781,       1873]
NotebookOptionsPosition[     68589,       1669]
NotebookOutlinePosition[     70842,       1721]
CellTagsIndexPosition[     70764,       1716]
WindowTitle->BrainwalletKey
WindowFrame->Normal*)

(* Beginning of Notebook Content *)
Notebook[{
Cell[BoxData[GridBox[{
   {GridBox[{
      {
       ItemBox[Cell[BoxData[
         RowBox[{
          TemplateBox[{12},
           "Spacer1"], Cell[
          "WOLFRAM INSTITUTE/ PUZZLES SYMBOL", "PacletNameCell",
           TextAlignment->Center,ExpressionUUID->
           "a5515f72-1c81-4691-98ea-63e8e9abbd4f"], 
          TemplateBox[{8},
           "Spacer1"]}]],
         TextAlignment->Center,ExpressionUUID->
         "68b2126f-b18e-4c3b-bf23-0735caa14a20"],
        Background->LightDarkSwitched[
          RGBColor[0.490196, 0.576471, 0.690196]],
        ItemSize->Full], ""}
     },
     GridBoxAlignment->{"Rows" -> {{Center}}},
     GridBoxItemSize->{"Columns" -> {Full, 
         Scaled[0.02]}, "Rows" -> {{2.5}}}], Cell[TextData[{
     Cell[BoxData[
      TagBox[
       ActionMenuBox[
        FrameBox[Cell[TextData[{
          "See Also",
          " ",
          Cell[BoxData[
           GraphicsBox[
            {GrayLevel[0.66667], Thickness[0.13], 
             LineBox[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]},
            AspectRatio->1,
            ImageSize->20,
            PlotRange->{{-3, 4}, {-1, 1}}]],ExpressionUUID->
           "a1714808-0d28-400e-8198-d341848fc68f"]
         }],ExpressionUUID->"5edf53aa-8085-4be5-a79c-a24db58ae737"],
         StripOnInput->False],{
        StyleBox["\"Hash\"", "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup["paclet:ref/Hash"], Delimiter, 
         StyleBox[
          "\"Functions\"", "SeeAlsoSection", FontSize -> 14, FontSlant -> 
           "Italic", StripOnInput -> False] :> 
         NotebookFind[EvaluationNotebook[], "SeeAlsoSection", All, CellStyle],
          StyleBox[
          StyleBox["\"BIP39Seed\"", "SeeAlsoRelated", StripOnInput -> False], 
           "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/BIP39Seed"], 
         StyleBox[
          StyleBox[
           "\"ElectrumV1MasterPrivateKey\"", "SeeAlsoRelated", StripOnInput -> 
            False], "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/ElectrumV1MasterPrivateKey"], 
         StyleBox[
          StyleBox["\"PBKDF2Key\"", "SeeAlsoRelated", StripOnInput -> False], 
           "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/PBKDF2Key"], 
         StyleBox[
          StyleBox["\"WIFEncode\"", "SeeAlsoRelated", StripOnInput -> False], 
           "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/WIFEncode"]},
        Appearance->None,
        MenuAppearance->Automatic,
        MenuStyle->"SeeAlso"],
       MouseAppearanceTag["LinkHand"]]],
      LineSpacing->{1.4, 0},ExpressionUUID->
      "fbda133e-1210-44af-9c39-a6441473cb8d"],
     "\[ThickSpace]\[ThickSpace]\[ThickSpace]\[ThickSpace]\[ThickSpace]\
\[ThickSpace]",
     Cell[BoxData[
      TagBox[
       ActionMenuBox[
        FrameBox[Cell[TextData[{
          "Related Guides",
          " ",
          Cell[BoxData[
           GraphicsBox[
            {GrayLevel[0.66667], Thickness[0.13], 
             LineBox[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]},
            AspectRatio->1,
            ImageSize->20,
            PlotRange->{{-3, 4}, {-1, 1}}]],ExpressionUUID->
           "7542e79e-ef91-4596-85ab-cb6ad9d0f1d9"]
         }],ExpressionUUID->"04ea98ad-69b4-4ed8-8453-0621316fe517"],
         StripOnInput->False],{
        "\"Seeds\"" :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/guide/Seeds"]},
        Appearance->None,
        MenuAppearance->Automatic,
        MenuStyle->"MoreAbout"],
       MouseAppearanceTag["LinkHand"]]],
      LineSpacing->{1.4, 0},ExpressionUUID->
      "67cd393c-371f-4741-be3b-72af117681f6"],
     "\[ThickSpace]\[ThickSpace]\[ThickSpace]\[ThickSpace]\[ThickSpace]\
\[ThickSpace]",
     Cell[BoxData[
      TagBox[
       ActionMenuBox[
        FrameBox[Cell[TextData[{
          "URL",
          " ",
          Cell[BoxData[
           GraphicsBox[
            {GrayLevel[0.66667], Thickness[0.13], 
             LineBox[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]},
            AspectRatio->1,
            ImageSize->20,
            PlotRange->{{-3, 4}, {-1, 1}}]],ExpressionUUID->
           "a01e6cfc-6ab9-48cc-8dea-8848a15ecea9"]
         }],ExpressionUUID->"dfc0c236-3810-4855-9e29-2d7679114acd"],
         StripOnInput->False],{
        "\"WolframInstitute/Puzzles/ref/BrainwalletKey\"" :> None, 
         "\"Copy Wolfram Documentation Center URL\"" :> 
         CopyToClipboard["WolframInstitute/Puzzles/ref/BrainwalletKey"], 
         Delimiter, "\"Copy web URL\"" :> 
         Module[{DocumentationSearch`Private`nb$}, 
           DocumentationSearch`Private`nb$ = 
            NotebookPut[
             Notebook[{
               Cell[BoxData[
                 MakeBoxes[
                  Hyperlink[
                   "http://reference.wolfram.com/language/WolframInstitute/\
Puzzles/ref/BrainwalletKey.html"], StandardForm]], "Input", TextClipboardType -> 
                 "PlainText"]}, Visible -> False]]; 
           SelectionMove[DocumentationSearch`Private`nb$, All, Notebook]; 
           FrontEndTokenExecute[DocumentationSearch`Private`nb$, "Copy"]; 
           NotebookClose[DocumentationSearch`Private`nb$]; Null], 
         "\"Go to web URL\"" :> 
         FrontEndExecute[{
           NotebookLocate[{
             URL[If[TrueQ[False], 
                 "http://reference.wolfram.com/system-modeler/", 
                 "http://reference.wolfram.com/language/"] <> 
               "WolframInstitute/Puzzles/ref/BrainwalletKey" <> ".html"], 
              None}]}]},
        Appearance->None,
        MenuAppearance->Automatic,
        MenuStyle->"URLMenu"],
       MouseAppearanceTag["LinkHand"]]],
      LineSpacing->{1.4, 0},ExpressionUUID->
      "5803f54a-ea98-41d4-b889-a1e1446bf706"]
    }], "AnchorBar",
     CacheGraphics->False,ExpressionUUID->
     "3cd24f94-ae25-43f5-8066-7641fc390869"]}
  }]], "AnchorBarGrid",
 CellID->1,ExpressionUUID->"10a1d0dc-897c-4098-979c-c046626d9990"],

Cell["WolframInstitute`Puzzles`", "ContextNameCell",ExpressionUUID->"965eba4f-5554-49ea-b4f5-d96fde851bf1"],

Cell[CellGroupData[{

Cell[BoxData[GridBox[{
   {Cell[TextData[{
     Cell[
     "BrainwalletKey", "ObjectName",ExpressionUUID->
      "074898b7-5daa-40fd-877c-eca74313adc8"],
     Cell[BoxData[
      TemplateBox[{8},
       "Spacer1"]],ExpressionUUID->"efc3b8ae-1e7b-4557-814c-0e6abc8a1de6"],
     Cell[BoxData[
     ""], "ObjectNameTranslation",ExpressionUUID->
      "6b0a8312-a3d0-478d-86b8-c473ddf43604"]
    }],ExpressionUUID->"1cd28520-0c99-41d3-abc5-76c425529af4"], 
    "\[SpanFromLeft]"}
  }]], "ObjectNameGrid",ExpressionUUID->"886e4848-5e1a-4176-bb11-\
ac65d5e8f3b0"],

Cell[BoxData[GridBox[{
   {"", Cell[TextData[{
     Cell[BoxData[
      RowBox[{
       TemplateBox[{
         Cell[
          TextData["BrainwalletKey"]], 
         "paclet:WolframInstitute/Puzzles/ref/BrainwalletKey", 
         "WolframInstitute/Puzzles Package Symbol"},
        "PackageLink",
        BaseStyle->"InlineFormula"], "[", 
       StyleBox["passphrase", "TI"], "]"}]], "InlineFormula",
      FontFamily->"Source Sans Pro",
      FontSize->0.9 Inherited,ExpressionUUID->
      "c74313e4-e5af-46dc-8ad8-3a3ec7a843df"],
     "\[LineSeparator]",
     "gives the classic brainwallet private key of ",
     StyleBox["passphrase", "TI"],
     ", the SHA-256 of its UTF-8 bytes, as a 32-byte ",
     Cell[BoxData[
      TemplateBox[{
        Cell[
         TextData["ByteArray"]], "paclet:ref/ByteArray"},
       "RefLink",
       BaseStyle->"InlineFormula"]], "InlineFormula",
      FontFamily->"Source Sans Pro",ExpressionUUID->
      "11954df7-92ef-4852-a5e8-38422d6cb7d0"],
     "."
    }],ExpressionUUID->"1ed025f0-d760-49c2-8a1b-6eb523c63a8d"]},
   {"", Cell[TextData[{
     Cell[BoxData[
      RowBox[{
       TemplateBox[{
         Cell[
          TextData["BrainwalletKey"]], 
         "paclet:WolframInstitute/Puzzles/ref/BrainwalletKey", 
         "WolframInstitute/Puzzles Package Symbol"},
        "PackageLink",
        BaseStyle->"InlineFormula"], "[", 
       RowBox[{
        StyleBox["passphrase", "TI"], ",", " ", 
        StyleBox["n", "TI"]}], "]"}]], "InlineFormula",
      FontFamily->"Source Sans Pro",
      FontSize->0.9 Inherited,ExpressionUUID->
      "8b77240f-0213-4cf6-b32e-ee469233eb30"],
     "\[LineSeparator]",
     "iterates the hash ",
     StyleBox["n", "TI"],
     " times."
    }],ExpressionUUID->"02147095-8e41-46c0-bb04-b98f79726ebf"]}
  }]], "Usage",ExpressionUUID->"63135350-7f98-476e-b05d-5bd6818ab407"]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[Cell[BoxData[Cell[TextData[{
  Cell[BoxData[
   DynamicBox[ToBoxes[
     If[CurrentValue[
        EvaluationCell[], "CellGroupOpen"] =!= Closed, 
      Style[
       Graphics[{
         Thickness[0.18], 
         RGBColor[0.8509803921568627, 0.396078431372549, 0], 
         Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
        PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
       0.68 Inherited], 
      Rotate[
       Style[
        Graphics[{
          Thickness[0.18], 
          RGBColor[0.8509803921568627, 0.396078431372549, 0], 
          Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
         PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
        0.68 Inherited], Rational[1, 2] Pi, {-1.65, -1}]]],
    ImageSizeCache->{
     13.600000000000001`, {-0.1685058593749993, 13.768505859375}}]],
   ExpressionUUID->"09826dd0-711a-4eed-8255-4268cc34b065"],
  Cell[BoxData[
   TemplateBox[{1},
    "Spacer1"]],ExpressionUUID->"a7473a6f-4eba-48e8-ba42-5bbc0d40fc58"],
  "Details and Options"
 }], "NotesFrameText",ExpressionUUID->
  "a09ad467-870e-4190-8378-79263b16ce2b"]],ExpressionUUID->"4ef95d2e-f712-\
441d-94e0-b4d106287d52"]], "NotesSection",
 ShowGroupOpener->"Thumbnail",
 WholeCellGroupOpener->True,
 CellGroupingRules->{"SectionGrouping", 50},
 CacheGraphics->False,
 CellID->1148781421,ExpressionUUID->"117e4820-949c-4250-b11f-65f7d4f84697"],

Cell[TextData[{
 "The classic scheme is one SHA-256 of the passphrase, which is what \
brainwallet.org and the tools that copied it produced. The iterated variant \
applies SHA-256 again to the 32 raw bytes, ",
 StyleBox["n", "TI"],
 " times in all."
}], "Notes",ExpressionUUID->"d07d4b4a-417d-4151-a8f2-12024f89895d"],

Cell[TextData[{
 StyleBox["passphrase", "TI"],
 " may be a ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["String"]], "paclet:ref/String"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "9e71fc39-bac6-47b7-a6d9-dad0d05c0917"],
 ", taken as its UTF-8 bytes, or a ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["ByteArray"]], "paclet:ref/ByteArray"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "e8e6c238-8320-4028-a998-3c7618ed61a0"],
 ", hashed exactly as supplied."
}], "Notes",ExpressionUUID->"f2e3507b-ec8c-4eee-bfb7-1bfe94752637"],

Cell["\<\
The passphrase is hashed verbatim. No trimming, no case folding, no Unicode \
normalization: a trailing newline or a leading space is a different key, and \
the historical tools did not agree on any of that.\
\>", "Notes",ExpressionUUID->"2b80f049-6f4b-41ab-93f1-4caab84e10c8"],

Cell[TextData[{
 StyleBox["n", "TI"],
 " must be a positive integer; anything else matches no definition and the \
call is returned unevaluated."
}], "Notes",ExpressionUUID->"f71cfa81-994f-4963-83a9-311e56e3e698"],

Cell["\<\
The 32 bytes are a secp256k1 private key only if they are nonzero and below \
the group order. That check, the public key and the address belong to the \
Derivation guide; nothing here knows what a Bitcoin address is.\
\>", "Notes",ExpressionUUID->"12795174-c700-4b3d-8238-348e92d05237"],

Cell[TextData[{
 "One call costs one ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["Hash"]], "paclet:ref/Hash"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "037a8af6-bf3d-4384-a533-c5bb6d8de904"],
 ", about 0.25 ms, so a passphrase sweep runs at roughly four thousand \
candidates a second."
}], "Notes",ExpressionUUID->"fb59c7de-cdb2-4fc0-836f-cd728338fc98"],

Cell["\<\
Salted, memory-hard passphrase wallets such as WarpWallet are out of scope.\
\>", "Notes",ExpressionUUID->"f3a42de2-26a3-4051-9a32-6119001cd63a"]
}, Closed]],

Cell["", "PageDelimiter",ExpressionUUID->"65530fd2-b663-4fb8-b49e-6d836662dc88"],

Cell[CellGroupData[{

Cell[TextData[{
 Cell[BoxData[
  DynamicBox[ToBoxes[
    If[
     MatchQ[
      CurrentValue[
       EvaluationNotebook[], {
       TaggingRules, "Openers", "PrimaryExamplesSection"}, Open], 
      Alternatives[True, Open]], 
     Style[
      Graphics[{
        Thickness[0.18], 
        RGBColor[0.8509803921568627, 0.396078431372549, 0], 
        Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
       PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
      0.68 Inherited], 
     Rotate[
      Style[
       Graphics[{
         Thickness[0.18], 
         RGBColor[0.8509803921568627, 0.396078431372549, 0], 
         Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
        PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
       0.68 Inherited], Rational[1, 2] Pi, {-1.65, -1}]]],
   ImageSizeCache->{
    13.600000000000001`, {4.251494140625001, 9.348505859375}}]],
  ExpressionUUID->"7f54b23c-30af-4248-99df-230fe53b6a4f"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"43a6a066-d6ad-48fb-91e1-abe841ff34f9"],
 "Examples",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(15)", "ExampleCount",ExpressionUUID->
  "84394f93-3ac4-4100-883e-addee97eaa69"]
}], "PrimaryExamplesSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->1691356217,ExpressionUUID->"24b7e72b-63ca-4fcd-8a51-45e6cb80024e"],

Cell[BoxData[
 RowBox[{"Needs", "[", "\"\<WolframInstitute`Puzzles`\>\"", "]"}]], "Input", \
"ExampleInitialization",
 CellLabel->"In[1]:=",
 CellID->1969679695,ExpressionUUID->"c6949204-3a63-472f-b802-8f9442e39513"],

Cell[CellGroupData[{

Cell[TextData[{
 Cell[BoxData[
  DynamicBox[ToBoxes[
    If[CurrentValue[
       EvaluationCell[], "CellGroupOpen"] =!= Closed, 
     Style[
      Graphics[{
        Thickness[0.18], 
        RGBColor[0.8509803921568627, 0.396078431372549, 0], 
        Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
       PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
      0.68 Inherited], 
     Rotate[
      Style[
       Graphics[{
         Thickness[0.18], 
         RGBColor[0.8509803921568627, 0.396078431372549, 0], 
         Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
        PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
       0.68 Inherited], Rational[1, 2] Pi, {-1.65, -1}]]]]],ExpressionUUID->
  "ea3df7ba-3cde-4052-a02f-ed74111f2d1b"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"f1ffb388-2b43-4662-9411-71042ae53c08"],
 "Basic Examples",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(3)", "ExampleCount",ExpressionUUID->
  "8096401c-e5e6-42f6-9bcb-346e26160451"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->382903780,ExpressionUUID->"6ccf96ce-c398-401b-9771-087546cb5ee5"],

Cell["\<\
The canonical published brainwallet, whose funds were swept within minutes of \
being deposited:\
\>", "ExampleText",
 CellTags->
  "TextAnnotation",ExpressionUUID->"bc9037e3-9261-493a-8658-3a5ddd30f215"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"ByteListToHexString", "[", 
  RowBox[{
  "BrainwalletKey", "[", "\"\<correct horse battery staple\>\"", "]"}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"73929c1b-0a6e-431d-9908-4721e73b3afc"],

Cell[BoxData["\<\"\
c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a\"\>"], \
"Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"3903ee74-aedf-4ad7-8fdc-3420bece04fa"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "cfe55852-3cc3-44ae-8d01-e67fc90476b3"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"6cdbd8db-f5c9-40c9-\
838d-2aac95ece877"],

Cell["The key is 32 bytes, the width of a secp256k1 scalar:", "ExampleText",ExpressionUUID->"9b9debef-f2ee-41df-a95a-63d4689c8904"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Length", "[", 
  RowBox[{
  "BrainwalletKey", "[", "\"\<correct horse battery staple\>\"", "]"}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"c7b23462-480c-48c4-b4ed-04430d06cbcd"],

Cell[BoxData["32"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"18adb645-ff61-48c7-b5e7-2ce33af259ba"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "f47dba52-4387-4794-8b2e-002f1e7587d5"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"bcdacdf2-252f-4b37-\
b88e-8638809e45c6"],

Cell["The iterated variant hashes the raw bytes again:", "ExampleText",ExpressionUUID->"9617807c-7bbb-4f8c-adb6-b5afbc1147c9"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"ByteListToHexString", "[", 
  RowBox[{"BrainwalletKey", "[", 
   RowBox[{"\"\<correct horse battery staple\>\"", ",", " ", "2"}], "]"}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"f65c1388-fc6c-4381-8874-ed998117ec27"],

Cell[BoxData["\<\"\
b867db875479bcc0287352cdaa4a1755689b8338777d0915e9acd9f6edbc96cb\"\>"], \
"Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"b08937a4-6127-4db4-a79d-abd2492ada10"]
}, Open  ]]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[TextData[{
 Cell[BoxData[
  DynamicBox[ToBoxes[
    If[CurrentValue[
       EvaluationCell[], "CellGroupOpen"] =!= Closed, 
     Style[
      Graphics[{
        Thickness[0.18], 
        RGBColor[0.8509803921568627, 0.396078431372549, 0], 
        Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
       PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
      0.68 Inherited], 
     Rotate[
      Style[
       Graphics[{
         Thickness[0.18], 
         RGBColor[0.8509803921568627, 0.396078431372549, 0], 
         Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
        PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
       0.68 Inherited], Rational[1, 2] Pi, {-1.65, -1}]]]]],ExpressionUUID->
  "104c48fb-6e77-48a4-abfb-b66da5af20e0"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"3818c8e4-bb45-4e81-ac28-3b6fe6c8598c"],
 "Scope",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(4)", "ExampleCount",ExpressionUUID->
  "cde4ec87-cbc9-4b32-8e7e-753d40807b7b"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->1293636265,ExpressionUUID->"97fec2f9-e97c-441c-af18-647eb2bf59bb"],

Cell["\<\
The one-block SHA-256 example of FIPS 180-4, which pins the digest \
independently of Bitcoin:\
\>", "ExampleText",ExpressionUUID->"5c9d64ed-c166-4971-97f8-32c99763847f"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"ByteListToHexString", "[", 
  RowBox[{"BrainwalletKey", "[", "\"\<abc\>\"", "]"}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"a13785a1-6a0a-4c34-8be6-6896aec07661"],

Cell[BoxData["\<\"\
ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad\"\>"], \
"Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"46983776-6532-41fc-bda1-2ed60a6d96f6"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "f59767e6-0411-4369-bd77-4c57ba26819e"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"44492029-888d-4e75-\
8bd6-a4f433a14ef8"],

Cell["\<\
A passphrase given as raw bytes is hashed exactly as supplied:\
\>", "ExampleText",ExpressionUUID->"404031d4-6ea0-4b5d-b0a3-ae5b052a1a5a"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{
  RowBox[{"BrainwalletKey", "[", 
   RowBox[{"StringToByteArray", "[", 
    RowBox[{"\"\<correct horse battery staple\>\"", ",", 
     " ", "\"\<UTF8\>\""}], "]"}], "]"}], " ", "===", " ", 
  RowBox[{
  "BrainwalletKey", "[", "\"\<correct horse battery staple\>\"", 
   "]"}]}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"921de1db-62bf-4e78-80f4-b00c4eba2803"],

Cell[BoxData["True"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"70cc92fc-d5cf-47d2-b325-3e58a3890318"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "4a425971-31a4-4708-917e-b326b07b73a0"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"60375af3-86ae-4c71-\
82b3-24028c7d06b5"],

Cell["\<\
The empty passphrase is still a passphrase, and its key is a famous constant:\
\
\>", "ExampleText",ExpressionUUID->"9ebd8eae-c650-4325-86e9-15f41dd785ca"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"ByteListToHexString", "[", 
  RowBox[{"BrainwalletKey", "[", "\"\<\>\"", "]"}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"ae43e274-5e6e-48ff-ac6b-33d397215aa1"],

Cell[BoxData["\<\"\
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\"\>"], \
"Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"94ca3ba8-cb16-4e07-8a0f-b7afd0a8c923"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "793e8e8e-011f-4854-aaa7-38ac10435cce"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"989db8d1-8767-4d06-\
8b1b-2201482b64f8"],

Cell["\<\
A non-positive iteration count is out of scope, and the call comes back \
unchanged:\
\>", "ExampleText",ExpressionUUID->"8a2e421d-2d61-4937-94b7-a91f82471c1c"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"BrainwalletKey", "[", 
  RowBox[{"\"\<correct horse battery staple\>\"", ",", " ", "0"}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"26bd5ca2-c931-4a08-b542-6893d8b30809"],

Cell[BoxData[
 RowBox[{"BrainwalletKey", "[", 
  RowBox[{"\<\"correct horse battery staple\"\>", ",", "0"}], "]"}]], "Output",\

 CellLabel->"Out[1]= ",ExpressionUUID->"cbe3520b-84f7-4cca-b284-bbc38700d6fd"]
}, Open  ]]
}, Open  ]]
}, Closed]],

Cell[CellGroupData[{

Cell[TextData[{
 Cell[BoxData[
  DynamicBox[ToBoxes[
    If[CurrentValue[
       EvaluationCell[], "CellGroupOpen"] =!= Closed, 
     Style[
      Graphics[{
        Thickness[0.18], 
        RGBColor[0.8509803921568627, 0.396078431372549, 0], 
        Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
       PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
      0.68 Inherited], 
     Rotate[
      Style[
       Graphics[{
         Thickness[0.18], 
         RGBColor[0.8509803921568627, 0.396078431372549, 0], 
         Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
        PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
       0.68 Inherited], Rational[1, 2] Pi, {-1.65, -1}]]]]],ExpressionUUID->
  "2e8bc279-dfa0-4aa8-8b1a-be61f06cb448"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"ab2c21c8-6429-456c-8ec5-be23244f05a9"],
 "Applications",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(2)", "ExampleCount",ExpressionUUID->
  "a444dd0f-d4d3-462d-85ef-089f74816bdd"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->258228157,ExpressionUUID->"ce0a7ca5-58be-4f30-9623-689655b9a69a"],

Cell["\<\
Sweeping a list of candidate phrases is a map, and the first sixteen digits \
are enough to compare against a target:\
\>", "ExampleText",ExpressionUUID->"90e9455d-2960-4473-a2b6-14a9dcb67947"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Dataset", "[", 
  RowBox[{"Map", "[", 
   RowBox[{
    RowBox[{"Function", "[", 
     RowBox[{"p", ",", " ", 
      RowBox[{"<|", 
       RowBox[{
        RowBox[{"\"\<phrase\>\"", " ", "->", " ", "p"}], ",", " ", 
        RowBox[{"\"\<key\>\"", " ", "->", " ", 
         RowBox[{"StringTake", "[", 
          RowBox[{
           RowBox[{"ByteListToHexString", "[", 
            RowBox[{"BrainwalletKey", "[", "p", "]"}], "]"}], ",", " ", 
           "16"}], "]"}]}]}], "|>"}]}], "]"}], ",", " ", 
    RowBox[{"{", 
     RowBox[{"\"\<correct horse battery staple\>\"", ",", 
      " ", "\"\<satoshi\>\"", ",", " ", "\"\<bitcoin\>\"", ",", 
      " ", "\"\<password\>\""}], "}"}]}], "]"}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"f0b387f0-6dd0-4053-b696-0d439b159fc8"],

Cell[BoxData[
 TagBox[
  TagBox[
   DynamicModuleBox[{TypeSystem`NestedGrid`PackagePrivate`$state$$ = <|
    "InitialData" -> {<|
       "phrase" -> "correct horse battery staple", "key" -> 
        "c4bbcb1fbec99d65"|>, <|
       "phrase" -> "satoshi", "key" -> "da2876b3eb31edb4"|>, <|
       "phrase" -> "bitcoin", "key" -> "6b88c087247aa2f0"|>, <|
       "phrase" -> "password", "key" -> "5e884898da280471"|>}, 
     "AllowEmbedding" -> True, "InitialShape" -> 
     TypeSystem`PackageScope`HeaderShape[<|{All, "phrase"} -> 1, {All, "key"} -> 
        1|>, 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          
          TypeSystem`PackageScope`RowShape[<|
           "phrase" -> TypeSystem`PackageScope`AtomShape[313.6], "key" -> 
            TypeSystem`PackageScope`AtomShape[179.20000000000002`]|>], 
          DirectedInfinity[1], 2, {All}]], 4, 
        DirectedInfinity[1], {}]], "InitialType" -> TypeSystem`Vector[
       TypeSystem`Struct[{"phrase", "key"}, {
         TypeSystem`Atom[String], 
         TypeSystem`Atom[String]}], 4], "Meta" -> <||>, "RowTarget" -> 20, 
     "ColumnTarget" -> 10, "Shape" -> 
     TypeSystem`PackageScope`HeaderShape[<|{All, "phrase"} -> 1, {All, "key"} -> 
        1|>, 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          
          TypeSystem`PackageScope`RowShape[<|
           "phrase" -> TypeSystem`PackageScope`AtomShape[313.6], "key" -> 
            TypeSystem`PackageScope`AtomShape[179.20000000000002`]|>], 
          DirectedInfinity[1], 2, {All}]], 4, 
        DirectedInfinity[1], {}]], "Type" -> TypeSystem`Vector[
       TypeSystem`Struct[{"phrase", "key"}, {
         TypeSystem`Atom[String], 
         TypeSystem`Atom[String]}], 4], "Path" -> {}, "DisplayedRowCount" -> 
     4, "DisplayedColumnCount" -> 2, "DataRowCount" -> 4, "DataColumnCount" -> 
     2, "SortPaths" -> {}, "SortDirections" -> {}, "HiddenItemsMap" -> Null, 
     "UpdateType" -> 1|>, TypeSystem`NestedGrid`PackagePrivate`$outputID$$, 
    TypeSystem`NestedGrid`PackagePrivate`$path$$ = {}, 
    TypeSystem`NestedGrid`PackagePrivate`$vPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$hPos$$ = 1, 
    TypeSystem`NestedGrid`PackagePrivate`$grid$$ = 
    DynamicModule[{
     TypeSystem`NestedGrid`PackagePrivate`renderedGrid = Deploy[
        Style[
         Grid[{{
            Item[
             Pane[
              Annotation[
               EventHandler[
                MouseAppearance[
                 Mouseover["phrase", 
                  Style[
                  "phrase", FontColor -> 
                   RGBColor[
                    0.2749633796890805, 0.536987306253161, 
                    0.791992189065661]]], "LinkHand"], {"MouseClicked", 1} :> 
                If[
                  TypeSystem`NestedGrid`PackagePrivate`checkInteractivity[
                  TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                  TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                   TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                   All, "phrase"}, 1]]], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                All, "phrase"}, "ColumnHeader", True], "Mouse"], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             RGBColor[
              0.9500473017990948, 0.9500473017990948, 0.9500473017990948], 
             Alignment -> {Left, Baseline}], 
            Item[
             Pane[
              Annotation[
               EventHandler[
                MouseAppearance[
                 Mouseover["key", 
                  Style[
                  "key", FontColor -> 
                   RGBColor[
                    0.2749633796890805, 0.536987306253161, 
                    0.791992189065661]]], "LinkHand"], {"MouseClicked", 1} :> 
                If[
                  TypeSystem`NestedGrid`PackagePrivate`checkInteractivity[
                  TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                  TypeSystem`NestedGrid`PackagePrivate`updateState[
                  TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                   TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                   TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][{
                   All, "key"}, 1]]], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                All, "key"}, "ColumnHeader", True], "Mouse"], 
              ImageSize -> {{1, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], Background -> 
             RGBColor[
              0.9500473017990948, 0.9500473017990948, 0.9500473017990948], 
             Alignment -> {Left, Baseline}]}, {
            Item[
             Pane[
              Annotation["correct horse battery staple", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["phrase"]}, "Item", False], "Mouse"], 
              ImageSize -> {{313.6, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation["c4bbcb1fbec99d65", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["key"]}, "Item", False], "Mouse"], 
              ImageSize -> {{179.20000000000002`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["satoshi", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["phrase"]}, "Item", False], "Mouse"], 
              ImageSize -> {{313.6, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation["da2876b3eb31edb4", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["key"]}, "Item", False], "Mouse"], 
              ImageSize -> {{179.20000000000002`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["bitcoin", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["phrase"]}, "Item", False], "Mouse"], 
              ImageSize -> {{313.6, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation["6b88c087247aa2f0", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["key"]}, "Item", False], "Mouse"], 
              ImageSize -> {{179.20000000000002`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["password", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["phrase"]}, "Item", False], "Mouse"], 
              ImageSize -> {{313.6, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation["5e884898da280471", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["key"]}, "Item", False], "Mouse"], 
              ImageSize -> {{179.20000000000002`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}}, 
          BaseStyle -> {
           ContextMenu -> 
            Dynamic[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
              Which[TypeSystem`NestedGrid`PackagePrivate`$lastOutputID =!= 
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                 TypeSystem`NestedGrid`PackagePrivate`$outputID$$], {}, 
                TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger === 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu, True, 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenuTrigger = 
                 TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger; 
                TypeSystem`NestedGrid`PackagePrivate`$lastContextMenu = 
                 Block[{TypeSystem`NestedGrid`PackagePrivate`$globalScrollPos = \
{TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$}}, 
                   
                   With[{TypeSystem`NestedGrid`PackagePrivate`lastPath$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$lastPathType, 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$ = 
                    TypeSystem`NestedGrid`PackagePrivate`$\
lastPathIsLeafHeader, TypeSystem`NestedGrid`PackagePrivate`headerHidden$ = And[
                    MatchQ[TypeSystem`NestedGrid`PackagePrivate`$lastPathType, 
                    Alternatives["RowHeader", "ColumnHeader"]], 
                    TypeSystem`NestedGrid`PackagePrivate`headerHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$]], 
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`allHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`anyHidden$ = 
                    TypeSystem`NestedGrid`PackagePrivate`anyHiddenQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ = 
                    TypeSystem`NestedGrid`PackagePrivate`columnSortDirection[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortPaths"], 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$[
                    "SortDirections"]], 
                    TypeSystem`NestedGrid`PackagePrivate`haveData$ = Not[
                    FailureQ[
                    TypeSystem`NestedGrid`PackagePrivate`datasetInitialData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$]]], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$ = Not[
                    FreeQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, Keys]]}, 
                    Join[{
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    Not[TypeSystem`NestedGrid`PackagePrivate`anyHidden$], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$], 
                    Nothing, 
                    MenuItem[
                    "Show " <> 
                    Which[TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "remove"]], MenuEvaluator -> Automatic]], 
                    If[
                    Or[
                    Not[TypeSystem`NestedGrid`PackagePrivate`haveData$], 
                    TypeSystem`NestedGrid`PackagePrivate`pathEmptyQ[
                    TypeSystem`NestedGrid`PackagePrivate`$lastPath, 
                    TypeSystem`NestedGrid`PackagePrivate`$state$$], 
                    TypeSystem`NestedGrid`PackagePrivate`isKeyDummy$, 
                    And[
                    TypeSystem`NestedGrid`PackagePrivate`allHidden$, 
                    TypeSystem`NestedGrid`PackagePrivate`headerHidden$]], 
                    Nothing, 
                    MenuItem[
                    "Hide " <> 
                    Which[TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "Item", "", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "RowHeader", "Row", 
                    TypeSystem`NestedGrid`PackagePrivate`lastPathType$ == 
                    "ColumnHeader", "Column", True, ""], 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateHiddenItems[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, "add"]], 
                    MenuEvaluator -> Automatic]], Delimiter}, 
                    If[
                    And[TypeSystem`NestedGrid`PackagePrivate`haveData$, 
                    MatchQ[TypeSystem`NestedGrid`PackagePrivate`lastPathType$, 
                    Alternatives["ColumnHeader", "KeyDummy"]], 
                    TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
                    Not[TypeSystem`NestedGrid`PackagePrivate`allHidden$]], {
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Ascending", 
                    MenuItem["Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Ascending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    "Descending", 
                    MenuItem["Reverse Sort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, 
                    "Descending"]], MenuEvaluator -> Automatic], Nothing], 
                    If[
                    TypeSystem`NestedGrid`PackagePrivate`sortDirection$ =!= 
                    None, 
                    MenuItem["Unsort", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`updateSort[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$path$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
                    TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
                    TypeSystem`NestedGrid`PackagePrivate`localHold[
                    TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
                    TypeSystem`NestedGrid`PackagePrivate`lastPath$, None]], 
                    MenuEvaluator -> Automatic], Nothing], Delimiter}, {}], {
                    MenuItem["Copy Position to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], 
                    If[TypeSystem`NestedGrid`PackagePrivate`haveData$, 
                    MenuItem["Copy Data to Clipboard", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`copyClip]], 
                    MenuEvaluator -> Automatic], Nothing], Delimiter, 
                    MenuItem["Paste Position in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentPosition[
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic], 
                    If[TypeSystem`NestedGrid`PackagePrivate`haveData$, 
                    MenuItem["Paste Data in New Cell", 
                    KernelExecute[
                    TypeSystem`NestedGrid`PackagePrivate`toCurrentData[
                    TypeSystem`NestedGrid`PackagePrivate`$state$$, 
                    TypeSystem`NestedGrid`PackagePrivate`cellPaste]], 
                    MenuEvaluator -> Automatic], Nothing]}]]]]], FontFamily -> 
            "Source Sans Pro", FontSize -> 14, FontWeight -> Plain}, Dividers -> 
          All, FrameStyle -> 
          RGBColor[0.749003690406716, 0.749003690406716, 0.749003690406716], 
          Spacings -> {0, 0}, Alignment -> Left, 
          BaseStyle -> {
           FontFamily -> "Source Sans Pro", FontSize -> 14, FontWeight -> 
            Plain}], LineBreakWithin -> False, ContextMenu -> {}, NumberMarks -> 
         False, ShowAutoStyles -> False]], 
      TypeSystem`NestedGrid`PackagePrivate`initialQ = True}, 
     Dynamic[
      TypeSystem`NestedGrid`PackagePrivate`setupViewPath[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, If[
         Not[TypeSystem`NestedGrid`PackagePrivate`initialQ], 
         Module[{
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = $Failed, 
           TypeSystem`NestedGrid`PackagePrivate`tmpData$ = 
           TypeSystem`NestedGrid`PackagePrivate`datasetData[
            TypeSystem`NestedGrid`PackagePrivate`$state$$]}, 
          TypeSystem`NestedGrid`PackagePrivate`tmpGrid$ = If[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpData$], 
             TypeSystem`NestedGrid`PackagePrivate`renderedGrid, 
             TypeSystem`NestedGrid`PackagePrivate`renderGrid[
             TypeSystem`NestedGrid`PackagePrivate`$state$$, 
              TypeSystem`NestedGrid`PackagePrivate`$path$$, 
              TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
              TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
              TypeSystem`NestedGrid`PackagePrivate`localHold[
              TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
             TypeSystem`NestedGrid`PackagePrivate`tmpData$]]; If[
            Not[
             FailureQ[TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]], 
            TypeSystem`NestedGrid`PackagePrivate`renderedGrid = 
            TypeSystem`NestedGrid`PackagePrivate`tmpGrid$]; Null]]; 
       TypeSystem`NestedGrid`PackagePrivate`initialQ = False; 
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$; 
       TypeSystem`NestedGrid`PackagePrivate`$hPos$$; If[
         FailureQ[TypeSystem`NestedGrid`PackagePrivate`renderedGrid], 
         TypeSystem`SparseGrid[
          TypeSystem`H["(data no longer present)"]], 
         TypeSystem`NestedGrid`PackagePrivate`renderedGrid]], 
      TrackedSymbols :> {
       TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$}], 
     DynamicModuleValues :> {}], 
    TypeSystem`NestedGrid`PackagePrivate`$topBar$$ = Dynamic[
     TypeSystem`NestedGrid`PackagePrivate`makeFramedBar[
      TypeSystem`PackageScope`SubViewPathbar[
      TypeSystem`NestedGrid`PackagePrivate`$path$$, 
       TypeSystem`NestedGrid`PackagePrivate`updateState[
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$path$$, 
        TypeSystem`NestedGrid`PackagePrivate`$vPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$hPos$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$, 
        TypeSystem`NestedGrid`PackagePrivate`localHold[
        TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]]], 
     TrackedSymbols :> {TypeSystem`NestedGrid`PackagePrivate`$path$$}], 
    TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$ = Dynamic[
     Replace[
      Replace[
      TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$, {
       TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
          TypeSystem`NestedGrid`PackagePrivate`localHold[
          TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][Null, 
          Blank[]] -> "", TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
          TypeSystem`NestedGrid`PackagePrivate`localHold[
          TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][
          Pattern[TypeSystem`NestedGrid`PackagePrivate`path$, 
           Blank[]], 
          Pattern[TypeSystem`NestedGrid`PackagePrivate`pathType$, 
           Blank[]], 
          Pattern[TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$, 
           Blank[]]] :> (
         Increment[TypeSystem`NestedGrid`PackagePrivate`$contextMenuTrigger]; 
         TypeSystem`NestedGrid`PackagePrivate`$lastPath = 
          TypeSystem`NestedGrid`PackagePrivate`path$; 
         TypeSystem`NestedGrid`PackagePrivate`$lastPathType = 
          TypeSystem`NestedGrid`PackagePrivate`pathType$; 
         TypeSystem`NestedGrid`PackagePrivate`$lastPathIsLeafHeader = 
          TypeSystem`NestedGrid`PackagePrivate`isLeafHeader$; 
         TypeSystem`NestedGrid`PackagePrivate`$lastOutputID = 
          TypeSystem`NestedGrid`PackagePrivate`localHold[
           TypeSystem`NestedGrid`PackagePrivate`$outputID$$]; 
         TypeSystem`NestedGrid`PackagePrivate`makePathTrail[
          TypeSystem`NestedGrid`PackagePrivate`path$, 
           TypeSystem`NestedGrid`PackagePrivate`makePathElements]), Null :> 
        Spacer[10], Blank[] :> Spacer[10]}], 
      Pattern[TypeSystem`NestedGrid`PackagePrivate`bar, 
        Except[
         Alternatives[
          Blank[Spacer], ""]]] :> 
      TypeSystem`NestedGrid`PackagePrivate`makeFramedPathbar[
       TypeSystem`NestedGrid`PackagePrivate`bar]], 
     TrackedSymbols :> {
      TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$}], 
    TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = Null}, 
    DynamicWrapperBox[
     DynamicBox[ToBoxes[
       Dataset`DatasetContent[
       2, "Path" -> Hold[TypeSystem`NestedGrid`PackagePrivate`$path$$], 
        "Grid" -> Hold[TypeSystem`NestedGrid`PackagePrivate`$grid$$], "State" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$state$$], "VPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$vPos$$], "HPos" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$hPos$$], "TopBar" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$topBar$$], "BottomBar" -> 
        Hold[TypeSystem`NestedGrid`PackagePrivate`$bottomBar$$], "OutputID" -> 
        Hold[
          TypeSystem`NestedGrid`PackagePrivate`localHold[
          TypeSystem`NestedGrid`PackagePrivate`$outputID$$]]], StandardForm],
      ImageSizeCache->{
       509.80000000000007`, {64.34909057617188, 69.64010620117188}},
      TrackedSymbols:>{
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$}], 
     TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = 
     MouseAnnotation[],
     ImageSizeCache->{
      509.80000000000007`, {64.34909057617188, 69.64010620117188}}],
    BaseStyle->{
     LineBreakWithin -> False, 
      LightDarkAutoColorRules -> <|"MarkedColors" -> True|>},
    DynamicModuleValues:>{},
    Initialization:>(TypeSystem`NestedGrid`PackagePrivate`$outputID$$ = 
     CreateUUID[]),
    UnsavedVariables:>{TypeSystem`NestedGrid`PackagePrivate`$outputID$$}],
   Deploy,
   DefaultBaseStyle->"Deploy"],
  Dataset`InterpretDataset[1],
  Editable->False,
  SelectWithContents->True,
  Selectable->False]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"d672f2eb-c017-4732-a14c-5aea8b1fe8d2"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "16130dc6-621a-4291-ae15-03352a60c0a3"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"52786585-2109-488e-\
bae3-b9d2c517fcdf"],

Cell["\<\
Iterating from one to five rounds shows how little the variant buys, since \
each round is a single hash:\
\>", "ExampleText",ExpressionUUID->"10b13110-a9dc-439d-9bb2-e76dc1fcb284"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Column", "[", 
  RowBox[{"Table", "[", 
   RowBox[{
    RowBox[{"n", " ", "->", " ", 
     RowBox[{"StringTake", "[", 
      RowBox[{
       RowBox[{"ByteListToHexString", "[", 
        RowBox[{"BrainwalletKey", "[", 
         RowBox[{"\"\<correct horse battery staple\>\"", ",", " ", "n"}], 
         "]"}], "]"}], ",", " ", "16"}], "]"}]}], ",", " ", 
    RowBox[{"{", 
     RowBox[{"n", ",", " ", "5"}], "}"}]}], "]"}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"ec393e2e-02d3-4790-9117-f9d609261d1b"],

Cell[BoxData[
 TagBox[GridBox[{
    {
     RowBox[{"1", "\[Rule]", "\<\"c4bbcb1fbec99d65\"\>"}]},
    {
     RowBox[{"2", "\[Rule]", "\<\"b867db875479bcc0\"\>"}]},
    {
     RowBox[{"3", "\[Rule]", "\<\"6915f8134c08694d\"\>"}]},
    {
     RowBox[{"4", "\[Rule]", "\<\"9876310ae466b652\"\>"}]},
    {
     RowBox[{"5", "\[Rule]", "\<\"945d337e443002ff\"\>"}]}
   },
   DefaultBaseStyle->"Column",
   GridBoxAlignment->{"Columns" -> {{Left}}},
   GridBoxItemSize->{"Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}],
  "Column"]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"c9e15a8a-8abe-4a3d-944f-e03b44b57136"]
}, Open  ]]
}, Open  ]]
}, Closed]],

Cell[CellGroupData[{

Cell[TextData[{
 Cell[BoxData[
  DynamicBox[ToBoxes[
    If[CurrentValue[
       EvaluationCell[], "CellGroupOpen"] =!= Closed, 
     Style[
      Graphics[{
        Thickness[0.18], 
        RGBColor[0.8509803921568627, 0.396078431372549, 0], 
        Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
       PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
      0.68 Inherited], 
     Rotate[
      Style[
       Graphics[{
         Thickness[0.18], 
         RGBColor[0.8509803921568627, 0.396078431372549, 0], 
         Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
        PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
       0.68 Inherited], Rational[1, 2] Pi, {-1.65, -1}]]]]],ExpressionUUID->
  "2cc819f0-07c3-456d-a03d-360cebff7788"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"2089b308-173a-400a-ba25-e8d7c4b4f0c9"],
 "Properties & Relations",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(3)", "ExampleCount",ExpressionUUID->
  "8e9511c0-0b11-430c-b824-e81317361d14"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->2123667759,ExpressionUUID->"d5001f4b-c0b7-445d-8e73-90967b55bc5d"],

Cell[TextData[{
 "Iterating composes, so ",
 StyleBox["n", "TI"],
 " rounds is one round applied to the result of ",
 StyleBox["n", "TI"],
 " - 1:"
}], "ExampleText",ExpressionUUID->"0b6a2760-8569-4f76-aa1b-eda26db89f12"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{
  RowBox[{"BrainwalletKey", "[", 
   RowBox[{"\"\<correct horse battery staple\>\"", ",", " ", "3"}], "]"}], 
  " ", "===", " ", 
  RowBox[{"BrainwalletKey", "[", 
   RowBox[{"BrainwalletKey", "[", 
    RowBox[{"\"\<correct horse battery staple\>\"", ",", " ", "2"}], "]"}], 
   "]"}]}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"d75c4c8b-d825-4966-a2a8-c6fda97b724a"],

Cell[BoxData["True"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"9eb2cb37-630d-4952-88fd-333024bb13cd"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "1136f5f6-3766-4b87-bb3e-6c47416c6924"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"29e8fafd-013d-4f8f-\
beca-35ceaa05eab8"],

Cell["One round is the plain scheme:", "ExampleText",ExpressionUUID->"381f5a22-3174-4514-9fcc-65f72655be95"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{
  RowBox[{"BrainwalletKey", "[", 
   RowBox[{"\"\<correct horse battery staple\>\"", ",", " ", "1"}], "]"}], 
  " ", "===", " ", 
  RowBox[{
  "BrainwalletKey", "[", "\"\<correct horse battery staple\>\"", 
   "]"}]}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"86a287b2-b0b1-4a2a-ba6c-ff75ad4b32f9"],

Cell[BoxData["True"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"cfb3623e-3a6f-42fd-9153-3da95cf6dd0e"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "cee78995-5abc-4ec8-beb6-1477c846bac9"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"d0ec3af3-2ee4-4ea0-\
9978-d55422701bb5"],

Cell[TextData[{
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["PBKDF2Key"]], "paclet:WolframInstitute/Puzzles/ref/PBKDF2Key", 
    "WolframInstitute/Puzzles Package Symbol"},
   "PackageLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "319d49c4-a783-4b7c-a1a4-3bed3a9cd46c"],
 " is the same idea with a salt and an iteration count that actually costs an \
attacker something:"
}], "ExampleText",ExpressionUUID->"95b9dd57-a012-408c-80e7-77b3b3406d44"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{
   RowBox[{"StringTake", "[", 
    RowBox[{
     RowBox[{"ByteListToHexString", "[", 
      RowBox[{"BrainwalletKey", "[", 
       RowBox[{"\"\<correct horse battery staple\>\"", ",", " ", "2048"}], 
       "]"}], "]"}], ",", " ", "16"}], "]"}], ",", " ", 
   RowBox[{"StringTake", "[", 
    RowBox[{
     RowBox[{"ByteListToHexString", "[", 
      RowBox[{"PBKDF2Key", "[", 
       RowBox[{"\"\<correct horse battery staple\>\"", ",", 
        " ", "\"\<salt\>\"", ",", " ", "2048", ",", " ", "32", ",", 
        " ", "\"\<SHA256\>\""}], "]"}], "]"}], ",", " ", "16"}], "]"}]}], 
  "}"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"7890b4c4-95ec-4eac-8443-24fda407e8e4"],

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{"\<\"a54e87dad7f12bf1\"\>", ",", "\<\"3830e18f2b428398\"\>"}], 
  "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"79d751ff-5a1e-4bda-96bb-03e2f59ef8d1"]
}, Open  ]]
}, Open  ]]
}, Closed]],

Cell[CellGroupData[{

Cell[TextData[{
 Cell[BoxData[
  DynamicBox[ToBoxes[
    If[CurrentValue[
       EvaluationCell[], "CellGroupOpen"] =!= Closed, 
     Style[
      Graphics[{
        Thickness[0.18], 
        RGBColor[0.8509803921568627, 0.396078431372549, 0], 
        Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
       PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
      0.68 Inherited], 
     Rotate[
      Style[
       Graphics[{
         Thickness[0.18], 
         RGBColor[0.8509803921568627, 0.396078431372549, 0], 
         Line[{{-1.8, 0.5}, {0, 0}, {1.8, 0.5}}]}, AspectRatio -> 1, 
        PlotRange -> {{-3, 4}, {-1, 1}}, ImageSize -> 20], Magnification -> 
       0.68 Inherited], Rational[1, 2] Pi, {-1.65, -1}]]]]],ExpressionUUID->
  "37b62e8a-c085-4df2-9f6c-2db44453a422"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"ca3e9414-47b5-422a-95fd-6095d9d89dad"],
 "Possible Issues",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(3)", "ExampleCount",ExpressionUUID->
  "197c0863-044a-42d0-af69-19b056a51546"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->1305812373,ExpressionUUID->"d5254e30-5421-49ad-8b3e-4bc1d826de12"],

Cell["\<\
Whitespace is significant, so a trailing newline from a text file is a \
different wallet:\
\>", "ExampleText",ExpressionUUID->"d43a61ed-d110-48af-ba0e-429b8d92709b"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{
  RowBox[{
  "BrainwalletKey", "[", "\"\<correct horse battery staple\n\>\"", "]"}], " ",
   "===", " ", 
  RowBox[{
  "BrainwalletKey", "[", "\"\<correct horse battery staple\>\"", 
   "]"}]}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"94ed8bd7-efcc-473a-82f6-6cd604d7c3de"],

Cell[BoxData["False"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"361c96f5-16cc-4fa6-8ff9-4fb896ded6d2"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "8be69c00-2747-45d1-a518-536862b8f37f"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"f305f115-48ac-474a-\
8601-2723bf02f759"],

Cell["\<\
Unicode is not normalized either, so two spellings of an accented passphrase \
are two wallets:\
\>", "ExampleText",ExpressionUUID->"4a02db85-2251-4901-a25d-9efbfc1da0cc"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{
  RowBox[{"BrainwalletKey", "[", 
   RowBox[{"FromCharacterCode", "[", 
    RowBox[{"{", 
     RowBox[{"99", ",", " ", "97", ",", " ", "102", ",", " ", "233"}], "}"}], 
    "]"}], "]"}], " ", "===", " ", 
  RowBox[{"BrainwalletKey", "[", 
   RowBox[{"FromCharacterCode", "[", 
    RowBox[{"{", 
     RowBox[{
     "99", ",", " ", "97", ",", " ", "102", ",", " ", "101", ",", " ", 
      "769"}], "}"}], "]"}], "]"}]}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"2c3bae6b-83c7-4eb1-8be6-7a44dc7865fb"],

Cell[BoxData["False"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"a3e606ea-d9a5-48f0-b5f5-3ce7a94e7caf"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "1ae49937-b7d7-4a6e-beb3-5d0362e34e47"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"b9f7213d-902d-45c4-\
a14c-709cc8eec650"],

Cell["\<\
The result is bytes, not a checked private key: the range test against the \
secp256k1 group order is in the Derivation guide:\
\>", "ExampleText",ExpressionUUID->"fbca56a6-b3f2-41d5-9342-d3ce507a45ef"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Head", "[", 
  RowBox[{
  "BrainwalletKey", "[", "\"\<correct horse battery staple\>\"", "]"}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"135912a5-771c-4f61-aed3-96c2ebc79513"],

Cell[BoxData["ByteArray"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"6ae1a8b7-f308-4146-a417-3c7e0840195a"]
}, Open  ]]
}, Open  ]]
}, Closed]]
}, Open  ]],

Cell[BoxData[GridBox[{
   {
    DynamicBox[FEPrivate`ImportImage[
      FrontEnd`FileName[{"Documentation", "FooterIcons"}, 
       "RelatedFunction.png"]],
     ImageSizeCache->{50., {26.47265625, 33.52734375}}], GridBox[{
      {
       StyleBox[
        RowBox[{"See", " ", "Also"}], "SeeAlsoSection"]},
      {Cell[TextData[{
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["BIP39Seed"]], 
           "paclet:WolframInstitute/Puzzles/ref/BIP39Seed", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "086579aa-0fa0-4141-8a6d-f8c2a27e93a8"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["ElectrumV1MasterPrivateKey"]], 
           "paclet:WolframInstitute/Puzzles/ref/ElectrumV1MasterPrivateKey", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "046ee739-de0c-4804-823b-9e0fc05fabe8"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["PBKDF2Key"]], 
           "paclet:WolframInstitute/Puzzles/ref/PBKDF2Key", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "2bb7671d-ee85-4d79-93d7-7c03190e63c3"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["Hash"]], "paclet:ref/Hash"},
          "RefLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "a01d89d3-0a6c-44b4-947d-b9896b396c5a"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["WIFEncode"]], 
           "paclet:WolframInstitute/Puzzles/ref/WIFEncode", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "681ef0b3-def4-4115-b0ae-d91a0df17fdf"]
       }], "SeeAlso",ExpressionUUID->"d102c7c6-8b5d-424b-81e2-9b60c1ef3e48"]}
     }]}
  }]], "SeeAlsoSection",ExpressionUUID->"d021ebaf-f97c-42a0-a355-\
73ac8f2a9612"],

Cell[BoxData[GridBox[{
   {
    DynamicBox[FEPrivate`ImportImage[
      FrontEnd`FileName[{"Documentation", "FooterIcons"}, "RelatedGuide.png"]],
     ImageSizeCache->{50., {26.47265625, 33.52734375}}], GridBox[{
      {
       StyleBox[
        RowBox[{"Related", " ", "Guides"}], "MoreAboutSection"]},
      {
       RowBox[{"\[FilledVerySmallSquare]", Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["Seeds"]], "paclet:WolframInstitute/Puzzles/guide/Seeds"},
          "RefLinkPlain",
          BaseStyle->{"MoreAbout"}]], "MoreAbout",ExpressionUUID->
         "8eb1cc66-5a8f-41a6-975e-21c1df4264cd"]}]}
     }]}
  }]], "MoreAboutSection",ExpressionUUID->"afe43454-31e1-445d-ad40-\
ca280f247971"],

Cell[" ", "FooterCell",ExpressionUUID->"162298a9-88ef-44f9-a420-00adfe8dbc70"]
},
Saveable->False,
ScreenStyleEnvironment->"Working",
WindowSize->{900, 830},
WindowMargins->{{0, Automatic}, {Automatic, 0}},
WindowTitle->"BrainwalletKey",
TaggingRules->{
 "ModificationHighlight" -> False, "ColorType" -> "", "LinkTrails" -> "", 
  "ExampleCounter" -> 1, 
  "Openers" -> {
   "PrimaryExamplesSection" -> Open, "ExampleSection" -> {"0" -> Open}, 
    "AllOptsTable" -> Closed}, "NewStyles" -> True, 
  "CitationPopupData" -> $Failed, "ShowCitation" -> False, "HasOptions" -> 
  True, "RootCaptions" -> "", "HeaderCoreAreaLink" -> {}, 
  "Metadata" -> {
   "built" -> "{2026, 8, 27, 0, 11, 6.136427}", 
    "history" -> {"XX", "", "", ""}, "context" -> "WolframInstitute`Puzzles`",
     "keywords" -> {}, "specialkeywords" -> {}, 
    "tutorialcollectionlinks" -> {}, "index" -> True, "label" -> 
    "Wolfram Institute/ Puzzles Symbol", "language" -> "en", "paclet" -> 
    "WolframInstitute/Puzzles", "status" -> "None", "summary" -> 
    "PackageLink[BrainwalletKey,paclet : \
WolframInstitute/Puzzles/ref/BrainwalletKey, WolframInstitute/Puzzles Package \
Symbol][passphrase] gives the classic brainwallet private key of passphrase, \
the SHA-256 of its UTF-8 bytes, as a 32-byte ByteArray. \
PackageLink[BrainwalletKey,paclet : \
WolframInstitute/Puzzles/ref/BrainwalletKey, WolframInstitute/Puzzles Package \
Symbol][passphrase, n] iterates the hash n times.", "synonyms" -> {}, 
    "tabletags" -> {}, "title" -> "BrainwalletKey", "titlemodifier" -> "", 
    "metadescription" -> "", "windowtitle" -> "BrainwalletKey", "type" -> 
    "Symbol", "uri" -> "WolframInstitute/Puzzles/ref/BrainwalletKey", 
    "WorkflowDockedCell" -> ""}, "SearchTextTranslated" -> ""},
CellContext->CellGroup,
FrontEndVersion->"15.0 for Mac OS X ARM (64-bit) (May 19, 2026)",
StyleDefinitions->FrontEnd`FileName[{"Wolfram"}, "Reference.nb"],
ExpressionUUID->"f223b04f-2f70-457a-aa5f-92b403699cbc"
]
(* End of Notebook Content *)

(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{
 "TextAnnotation"->{
  Cell[16283, 436, 214, 5, 70, "ExampleText",ExpressionUUID->"bc9037e3-9261-493a-8658-3a5ddd30f215",
   CellTags->"TextAnnotation"]}
 }
*)
(*CellTagsIndex
CellTagsIndex->{
 {"TextAnnotation", 70607, 1710}
 }
*)
(*NotebookFileOutline
Notebook[{
Cell[582, 21, 6235, 150, 70, "AnchorBarGrid",ExpressionUUID->"10a1d0dc-897c-4098-979c-c046626d9990",
 CellID->1],
Cell[6820, 173, 107, 0, 70, "ContextNameCell",ExpressionUUID->"965eba4f-5554-49ea-b4f5-d96fde851bf1"],
Cell[CellGroupData[{
Cell[6952, 177, 557, 14, 70, "ObjectNameGrid",ExpressionUUID->"886e4848-5e1a-4176-bb11-ac65d5e8f3b0"],
Cell[7512, 193, 1856, 50, 70, "Usage",ExpressionUUID->"63135350-7f98-476e-b05d-5bd6818ab407"]
}, Open  ]],
Cell[CellGroupData[{
Cell[9405, 248, 1444, 34, 70, "NotesSection",ExpressionUUID->"117e4820-949c-4250-b11f-65f7d4f84697",
 CellGroupingRules->{"SectionGrouping", 50},
 CellID->1148781421],
Cell[10852, 284, 318, 6, 70, "Notes",ExpressionUUID->"d07d4b4a-417d-4151-a8f2-12024f89895d"],
Cell[11173, 292, 696, 21, 70, "Notes",ExpressionUUID->"f2e3507b-ec8c-4eee-bfb7-1bfe94752637"],
Cell[11872, 315, 287, 4, 70, "Notes",ExpressionUUID->"2b80f049-6f4b-41ab-93f1-4caab84e10c8"],
Cell[12162, 321, 213, 4, 70, "Notes",ExpressionUUID->"f71cfa81-994f-4963-83a9-311e56e3e698"],
Cell[12378, 327, 297, 4, 70, "Notes",ExpressionUUID->"12795174-c700-4b3d-8238-348e92d05237"],
Cell[12678, 333, 443, 12, 70, "Notes",ExpressionUUID->"fb59c7de-cdb2-4fc0-836f-cd728338fc98"],
Cell[13124, 347, 155, 2, 70, "Notes",ExpressionUUID->"f3a42de2-26a3-4051-9a32-6119001cd63a"]
}, Closed]],
Cell[13294, 352, 80, 0, 70, "PageDelimiter",ExpressionUUID->"65530fd2-b663-4fb8-b49e-6d836662dc88"],
Cell[CellGroupData[{
Cell[13399, 356, 1402, 37, 70, "PrimaryExamplesSection",ExpressionUUID->"24b7e72b-63ca-4fcd-8a51-45e6cb80024e",
 CellID->1691356217],
Cell[14804, 395, 216, 4, 70, "Input",ExpressionUUID->"c6949204-3a63-472f-b802-8f9442e39513",
 CellID->1969679695],
Cell[CellGroupData[{
Cell[15045, 403, 1235, 31, 70, "ExampleSection",ExpressionUUID->"6ccf96ce-c398-401b-9771-087546cb5ee5",
 CellID->382903780],
Cell[16283, 436, 214, 5, 70, "ExampleText",ExpressionUUID->"bc9037e3-9261-493a-8658-3a5ddd30f215",
 CellTags->"TextAnnotation"],
Cell[CellGroupData[{
Cell[16522, 445, 281, 6, 70, "Input",ExpressionUUID->"73929c1b-0a6e-431d-9908-4721e73b3afc"],
Cell[16806, 453, 182, 3, 70, "Output",ExpressionUUID->"3903ee74-aedf-4ad7-8fdc-3420bece04fa"]
}, Open  ]],
Cell[CellGroupData[{
Cell[17025, 461, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"6cdbd8db-f5c9-40c9-838d-2aac95ece877"],
Cell[17252, 468, 131, 0, 70, "ExampleText",ExpressionUUID->"9b9debef-f2ee-41df-a95a-63d4689c8904"],
Cell[CellGroupData[{
Cell[17408, 472, 268, 6, 70, "Input",ExpressionUUID->"c7b23462-480c-48c4-b4ed-04430d06cbcd"],
Cell[17679, 480, 108, 1, 70, "Output",ExpressionUUID->"18adb645-ff61-48c7-b5e7-2ce33af259ba"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[17836, 487, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"bcdacdf2-252f-4b37-b88e-8638809e45c6"],
Cell[18063, 494, 126, 0, 70, "ExampleText",ExpressionUUID->"9617807c-7bbb-4f8c-adb6-b5afbc1147c9"],
Cell[CellGroupData[{
Cell[18214, 498, 307, 6, 70, "Input",ExpressionUUID->"f65c1388-fc6c-4381-8874-ed998117ec27"],
Cell[18524, 506, 182, 3, 70, "Output",ExpressionUUID->"b08937a4-6127-4db4-a79d-abd2492ada10"]
}, Open  ]]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[18767, 516, 1227, 31, 70, "ExampleSection",ExpressionUUID->"97fec2f9-e97c-441c-af18-647eb2bf59bb",
 CellID->1293636265],
Cell[19997, 549, 180, 3, 70, "ExampleText",ExpressionUUID->"5c9d64ed-c166-4971-97f8-32c99763847f"],
Cell[CellGroupData[{
Cell[20202, 556, 250, 4, 70, "Input",ExpressionUUID->"a13785a1-6a0a-4c34-8be6-6896aec07661"],
Cell[20455, 562, 182, 3, 70, "Output",ExpressionUUID->"46983776-6532-41fc-bda1-2ed60a6d96f6"]
}, Open  ]],
Cell[CellGroupData[{
Cell[20674, 570, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"44492029-888d-4e75-8bd6-a4f433a14ef8"],
Cell[20901, 577, 148, 2, 70, "ExampleText",ExpressionUUID->"404031d4-6ea0-4b5d-b0a3-ae5b052a1a5a"],
Cell[CellGroupData[{
Cell[21074, 583, 439, 10, 70, "Input",ExpressionUUID->"921de1db-62bf-4e78-80f4-b00c4eba2803"],
Cell[21516, 595, 110, 1, 70, "Output",ExpressionUUID->"70cc92fc-d5cf-47d2-b325-3e58a3890318"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[21675, 602, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"60375af3-86ae-4c71-82b3-24028c7d06b5"],
Cell[21902, 609, 165, 3, 70, "ExampleText",ExpressionUUID->"9ebd8eae-c650-4325-86e9-15f41dd785ca"],
Cell[CellGroupData[{
Cell[22092, 616, 247, 4, 70, "Input",ExpressionUUID->"ae43e274-5e6e-48ff-ac6b-33d397215aa1"],
Cell[22342, 622, 182, 3, 70, "Output",ExpressionUUID->"94ca3ba8-cb16-4e07-8a0f-b7afd0a8c923"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[22573, 631, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"989db8d1-8767-4d06-8b1b-2201482b64f8"],
Cell[22800, 638, 170, 3, 70, "ExampleText",ExpressionUUID->"8a2e421d-2d61-4937-94b7-a91f82471c1c"],
Cell[CellGroupData[{
Cell[22995, 645, 260, 5, 70, "Input",ExpressionUUID->"26bd5ca2-c931-4a08-b542-6893d8b30809"],
Cell[23258, 652, 207, 4, 70, "Output",ExpressionUUID->"cbe3520b-84f7-4cca-b284-bbc38700d6fd"]
}, Open  ]]
}, Open  ]]
}, Closed]],
Cell[CellGroupData[{
Cell[23526, 663, 1233, 31, 70, "ExampleSection",ExpressionUUID->"ce0a7ca5-58be-4f30-9623-689655b9a69a",
 CellID->258228157],
Cell[24762, 696, 203, 3, 70, "ExampleText",ExpressionUUID->"90e9455d-2960-4473-a2b6-14a9dcb67947"],
Cell[CellGroupData[{
Cell[24990, 703, 856, 20, 70, "Input",ExpressionUUID->"f0b387f0-6dd0-4053-b696-0d439b159fc8"],
Cell[25849, 725, 28265, 512, 70, "Output",ExpressionUUID->"d672f2eb-c017-4732-a14c-5aea8b1fe8d2"]
}, Open  ]],
Cell[CellGroupData[{
Cell[54151, 1242, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"52786585-2109-488e-bae3-b9d2c517fcdf"],
Cell[54378, 1249, 191, 3, 70, "ExampleText",ExpressionUUID->"10b13110-a9dc-439d-9bb2-e76dc1fcb284"],
Cell[CellGroupData[{
Cell[54594, 1256, 590, 14, 70, "Input",ExpressionUUID->"ec393e2e-02d3-4790-9117-f9d609261d1b"],
Cell[55187, 1272, 622, 17, 70, "Output",ExpressionUUID->"c9e15a8a-8abe-4a3d-944f-e03b44b57136"]
}, Open  ]]
}, Open  ]]
}, Closed]],
Cell[CellGroupData[{
Cell[55870, 1296, 1244, 31, 70, "ExampleSection",ExpressionUUID->"d5001f4b-c0b7-445d-8e73-90967b55bc5d",
 CellID->2123667759],
Cell[57117, 1329, 221, 6, 70, "ExampleText",ExpressionUUID->"0b6a2760-8569-4f76-aa1b-eda26db89f12"],
Cell[CellGroupData[{
Cell[57363, 1339, 448, 10, 70, "Input",ExpressionUUID->"d75c4c8b-d825-4966-a2a8-c6fda97b724a"],
Cell[57814, 1351, 110, 1, 70, "Output",ExpressionUUID->"9eb2cb37-630d-4952-88fd-333024bb13cd"]
}, Open  ]],
Cell[CellGroupData[{
Cell[57961, 1357, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"29e8fafd-013d-4f8f-beca-35ceaa05eab8"],
Cell[58188, 1364, 108, 0, 70, "ExampleText",ExpressionUUID->"381f5a22-3174-4514-9fcc-65f72655be95"],
Cell[CellGroupData[{
Cell[58321, 1368, 379, 9, 70, "Input",ExpressionUUID->"86a287b2-b0b1-4a2a-ba6c-ff75ad4b32f9"],
Cell[58703, 1379, 110, 1, 70, "Output",ExpressionUUID->"cfb3623e-3a6f-42fd-9153-3da95cf6dd0e"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[58862, 1386, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"d0ec3af3-2ee4-4ea0-9978-d55422701bb5"],
Cell[59089, 1393, 545, 13, 70, "ExampleText",ExpressionUUID->"95b9dd57-a012-408c-80e7-77b3b3406d44"],
Cell[CellGroupData[{
Cell[59659, 1410, 766, 18, 70, "Input",ExpressionUUID->"7890b4c4-95ec-4eac-8443-24fda407e8e4"],
Cell[60428, 1430, 201, 4, 70, "Output",ExpressionUUID->"79d751ff-5a1e-4bda-96bb-03e2f59ef8d1"]
}, Open  ]]
}, Open  ]]
}, Closed]],
Cell[CellGroupData[{
Cell[60690, 1441, 1237, 31, 70, "ExampleSection",ExpressionUUID->"d5254e30-5421-49ad-8b3e-4bc1d826de12",
 CellID->1305812373],
Cell[61930, 1474, 176, 3, 70, "ExampleText",ExpressionUUID->"d43a61ed-d110-48af-ba0e-429b8d92709b"],
Cell[CellGroupData[{
Cell[62131, 1481, 355, 9, 70, "Input",ExpressionUUID->"94ed8bd7-efcc-473a-82f6-6cd604d7c3de"],
Cell[62489, 1492, 111, 1, 70, "Output",ExpressionUUID->"361c96f5-16cc-4fa6-8ff9-4fb896ded6d2"]
}, Open  ]],
Cell[CellGroupData[{
Cell[62637, 1498, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"f305f115-48ac-474a-8601-2723bf02f759"],
Cell[62864, 1505, 181, 3, 70, "ExampleText",ExpressionUUID->"4a02db85-2251-4901-a25d-9efbfc1da0cc"],
Cell[CellGroupData[{
Cell[63070, 1512, 579, 14, 70, "Input",ExpressionUUID->"2c3bae6b-83c7-4eb1-8be6-7a44dc7865fb"],
Cell[63652, 1528, 111, 1, 70, "Output",ExpressionUUID->"a3e606ea-d9a5-48f0-b5f5-3ce7a94e7caf"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[63812, 1535, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"b9f7213d-902d-45c4-a14c-709cc8eec650"],
Cell[64039, 1542, 212, 3, 70, "ExampleText",ExpressionUUID->"fbca56a6-b3f2-41d5-9342-d3ce507a45ef"],
Cell[CellGroupData[{
Cell[64276, 1549, 266, 6, 70, "Input",ExpressionUUID->"135912a5-771c-4f61-aed3-96c2ebc79513"],
Cell[64545, 1557, 115, 1, 70, "Output",ExpressionUUID->"6ae1a8b7-f308-4146-a417-3c7e0840195a"]
}, Open  ]]
}, Open  ]]
}, Closed]]
}, Open  ]],
Cell[64711, 1564, 3064, 81, 70, "SeeAlsoSection",ExpressionUUID->"d021ebaf-f97c-42a0-a355-73ac8f2a9612"],
Cell[67778, 1647, 726, 18, 70, "MoreAboutSection",ExpressionUUID->"afe43454-31e1-445d-ad40-ca280f247971"],
Cell[68507, 1667, 78, 0, 70, "FooterCell",ExpressionUUID->"162298a9-88ef-44f9-a420-00adfe8dbc70"]
}
]
*)

(* End of internal cache information *)

