(* 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[    107114,       2478]
NotebookOptionsPosition[     96519,       2285]
NotebookOutlinePosition[     98599,       2334]
CellTagsIndexPosition[     98521,       2329]
WindowTitle->ImageContainerChunks
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->
           "87ee118d-f090-43d5-88cc-577801d2f3ed"], 
          TemplateBox[{8},
           "Spacer1"]}]],
         TextAlignment->Center,ExpressionUUID->
         "2a269f5d-6eb5-4a8b-82a5-d339ed04d9ad"],
        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->
           "840dca6f-c2ab-44ef-a7be-f74fe1d4b249"]
         }],ExpressionUUID->"8cb4b3e4-4088-459d-839b-8cdcbad54b88"],
         StripOnInput->False],{
        StyleBox["\"Import\"", "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup["paclet:ref/Import"], Delimiter, 
         StyleBox[
          "\"Functions\"", "SeeAlsoSection", FontSize -> 14, FontSlant -> 
           "Italic", StripOnInput -> False] :> 
         NotebookFind[EvaluationNotebook[], "SeeAlsoSection", All, CellStyle],
          StyleBox[
          StyleBox[
           "\"ImageAppendedData\"", "SeeAlsoRelated", StripOnInput -> False], 
           "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/ImageAppendedData"], 
         StyleBox[
          StyleBox[
           "\"ImageTextMetadata\"", "SeeAlsoRelated", StripOnInput -> False], 
           "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/ImageTextMetadata"], 
         StyleBox[
          StyleBox[
           "\"EmbeddedFileSignatures\"", "SeeAlsoRelated", StripOnInput -> 
            False], "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/EmbeddedFileSignatures"], 
         StyleBox[
          StyleBox[
           "\"SteganographySurvey\"", "SeeAlsoRelated", StripOnInput -> 
            False], "SeeAlsoRelated", StripOnInput -> False] :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/ref/SteganographySurvey"]},
        Appearance->None,
        MenuAppearance->Automatic,
        MenuStyle->"SeeAlso"],
       MouseAppearanceTag["LinkHand"]]],
      LineSpacing->{1.4, 0},ExpressionUUID->
      "7b089455-d112-4891-87c0-75ac2376d104"],
     "\[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->
           "0399caef-e0a2-479f-8386-9c836a0ef474"]
         }],ExpressionUUID->"a52d032b-dc09-4e7d-b524-5d114e8753ea"],
         StripOnInput->False],{
        "\"Steganography\"" :> 
         Documentation`HelpLookup[
          "paclet:WolframInstitute/Puzzles/guide/Steganography"]},
        Appearance->None,
        MenuAppearance->Automatic,
        MenuStyle->"MoreAbout"],
       MouseAppearanceTag["LinkHand"]]],
      LineSpacing->{1.4, 0},ExpressionUUID->
      "c9a1962b-4ecf-46f8-964b-428c3dbe5f05"],
     "\[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->
           "4c7121d4-5695-4728-94a3-8ee517014c13"]
         }],ExpressionUUID->"f7ac7673-5fb0-4579-852d-22c6c1e87620"],
         StripOnInput->False],{
        "\"WolframInstitute/Puzzles/ref/ImageContainerChunks\"" :> None, 
         "\"Copy Wolfram Documentation Center URL\"" :> 
         CopyToClipboard["WolframInstitute/Puzzles/ref/ImageContainerChunks"],
          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/ImageContainerChunks.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/ImageContainerChunks" <> 
               ".html"], None}]}]},
        Appearance->None,
        MenuAppearance->Automatic,
        MenuStyle->"URLMenu"],
       MouseAppearanceTag["LinkHand"]]],
      LineSpacing->{1.4, 0},ExpressionUUID->
      "3a8ab32b-fbe2-4a58-bcd7-100b370d320c"]
    }], "AnchorBar",
     CacheGraphics->False,ExpressionUUID->
     "c6673dbf-7062-4222-b1f9-394b3dee33a8"]}
  }]], "AnchorBarGrid",
 CellID->1,ExpressionUUID->"47e9f318-19be-47c2-9372-7360b00b4198"],

Cell["WolframInstitute`Puzzles`", "ContextNameCell",ExpressionUUID->"dfc8288d-1431-4282-abfc-80cf5366312c"],

Cell[CellGroupData[{

Cell[BoxData[GridBox[{
   {Cell[TextData[{
     Cell[
     "ImageContainerChunks", "ObjectName",ExpressionUUID->
      "fc36530a-66d9-49ab-80ec-2cdf1de4e22a"],
     Cell[BoxData[
      TemplateBox[{8},
       "Spacer1"]],ExpressionUUID->"c16befaf-50a6-492d-9ef2-a0623f93dcb0"],
     Cell[BoxData[
     ""], "ObjectNameTranslation",ExpressionUUID->
      "ca185aa5-4b35-430f-b18c-6ab715b63f59"]
    }],ExpressionUUID->"854e5f77-0935-4e02-84b9-465d9c27dce7"], 
    "\[SpanFromLeft]"}
  }]], "ObjectNameGrid",ExpressionUUID->"8e02c5e3-344c-469e-b125-\
5a2a0b449ea1"],

Cell[BoxData[GridBox[{
   {"", Cell[TextData[{
     Cell[BoxData[
      RowBox[{
       TemplateBox[{
         Cell[
          TextData["ImageContainerChunks"]], 
         "paclet:WolframInstitute/Puzzles/ref/ImageContainerChunks", 
         "WolframInstitute/Puzzles Package Symbol"},
        "PackageLink",
        BaseStyle->"InlineFormula"], "[", 
       StyleBox["source", "TI"], "]"}]], "InlineFormula",
      FontFamily->"Source Sans Pro",
      FontSize->0.9 Inherited,ExpressionUUID->
      "d917cfaa-0b88-410e-9193-7546f0ca5258"],
     "\[LineSeparator]",
     "gives the structural units of an image container as a list of \
Associations."
    }],ExpressionUUID->"79ee1dd9-0ec4-4b27-a44c-c565633325e3"]}
  }]], "Usage",ExpressionUUID->"3c2922eb-439a-4e8d-b737-9e92675801da"]
}, 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->"270ae30d-d3ce-47a8-bf7a-8a826aeb8660"],
  Cell[BoxData[
   TemplateBox[{1},
    "Spacer1"]],ExpressionUUID->"48c4cd6d-8bd5-4d33-81bf-87f778d9cfa7"],
  "Details and Options"
 }], "NotesFrameText",ExpressionUUID->
  "365316d4-2e4d-426b-8344-b95413f9f714"]],ExpressionUUID->"7b9ea652-0462-\
4a2b-b14a-129ff6267f8b"]], "NotesSection",
 ShowGroupOpener->"Thumbnail",
 WholeCellGroupOpener->True,
 CellGroupingRules->{"SectionGrouping", 50},
 CacheGraphics->False,
 CellID->1268181061,ExpressionUUID->"ea9f2716-fb6d-480a-be29-f1c69b129294"],

Cell[TextData[{
 StyleBox["source", "TI"],
 " is a ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["File"]], "paclet:ref/File"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "a9802eb5-8851-42ae-b5fd-c6b05feb1103"],
 ", a file path, or a ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["ByteArray"]], "paclet:ref/ByteArray"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "cfb9bede-3e05-492e-b56e-7b5839053a63"],
 "."
}], "Notes",ExpressionUUID->"f6c3c7c1-5463-43d2-ba17-a671ee6b9f4a"],

Cell[TextData[{
 "Every unit records its ",
 Cell[BoxData["\<\"Name\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "12d8512d-1151-49b1-96f6-1d2349bdb8f5"],
 ", its 0-based ",
 Cell[BoxData["\<\"Position\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "94184696-07d5-49dd-89df-35f22e445f3a"],
 " in the file, its payload ",
 Cell[BoxData["\<\"Length\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "db6cdd03-0d2c-4b64-9c6a-544eec497f10"],
 " and its ",
 Cell[BoxData["\<\"Data\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "ed48d503-9cec-439b-bcb8-2f80aabf2179"],
 " as a ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["ByteArray"]], "paclet:ref/ByteArray"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "842af2b0-1ad8-41ac-87ed-fe712fcad7d7"],
 "."
}], "Notes",ExpressionUUID->"b1e5ad9a-ddcb-4380-83f2-e95f75609562"],

Cell[TextData[{
 "PNG chunks also record ",
 Cell[BoxData["\<\"CRCValid\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "67cb851a-fbb8-4ca1-a6dc-87c646926160"],
 ", the result of recomputing the chunk's CRC-32 over its type and data as \
the PNG Specification requires."
}], "Notes",ExpressionUUID->"f2793d3b-a3ac-45db-9f11-336f3cd348e1"],

Cell[TextData[{
 "JPEG marker segments also record ",
 Cell[BoxData["\<\"Marker\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "0c79f87d-5660-401d-a3b2-15b2888bfa56"],
 ", the marker's second byte. The entropy-coded data after a scan header is \
reported as one unit named ",
 Cell[BoxData["\<\"ECS\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "196191f5-bc49-4baf-9125-95d1044f3df3"],
 " and is never decoded."
}], "Notes",ExpressionUUID->"adfc19c6-6991-406b-af99-c661ad4e02a5"],

Cell[TextData[{
 "GIF units are the ",
 Cell[BoxData["\<\"Header\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "af7f0c1a-f90e-4853-a2d8-8fee8c396eb7"],
 ", the ",
 Cell[BoxData["\<\"LogicalScreenDescriptor\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "f839fbd4-0145-4bf7-b06c-fbbc707b600a"],
 ", an optional ",
 Cell[BoxData["\<\"GlobalColorTable\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "ab345db8-5458-40ed-9abe-7d38e5817e30"],
 ", the extension blocks, each ",
 Cell[BoxData["\<\"ImageDescriptor\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "ab65d6b7-52a8-4102-815b-88d144afa7ea"],
 " with its compressed data, and the ",
 Cell[BoxData["\<\"Trailer\"\>"], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "e89b6dab-c913-4c52-89d4-df6295cfd834"],
 "."
}], "Notes",ExpressionUUID->"d871618e-ecd2-4a2c-9663-a8b957279d7e"],

Cell[TextData[{
 "Units are contiguous and in file order, so the position and length of the \
last unit say where the container ends. ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["ImageAppendedData"]], 
    "paclet:WolframInstitute/Puzzles/ref/ImageAppendedData", 
    "WolframInstitute/Puzzles Package Symbol"},
   "PackageLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "61856f31-9494-4aac-87e3-e400f2d8a16c"],
 " reads whatever is past it."
}], "Notes",ExpressionUUID->"55ad1827-01dd-4eda-8e79-1dbb8b3884db"],

Cell[TextData[{
 "A source that is not a PNG, JPEG or GIF is an attempt that engaged and \
could not finish, and gives a ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["Failure"]], "paclet:ref/Failure"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "3cb0f75d-1ae4-475b-8ca8-ca95623204d5"],
 ". A first argument that is not a source at all matches no definition and is \
returned unevaluated."
}], "Notes",ExpressionUUID->"b096dbed-7323-442d-b6f6-fa3afe1a9f83"]
}, Closed]],

Cell["", "PageDelimiter",ExpressionUUID->"cd334b28-dec1-42bf-a83e-499d59f005cc"],

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->"7693bbf2-ba4d-4ccf-a375-f2458ec5b1fc"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"23f2b8e8-c174-4fd4-b0d3-c9931f7a2783"],
 "Examples",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(14)", "ExampleCount",ExpressionUUID->
  "da4cf6f2-12d4-48ae-b5d0-c4a68f992fe3"]
}], "PrimaryExamplesSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->543895752,ExpressionUUID->"bd8b9447-80dc-4108-ba80-392426635537"],

Cell[BoxData[
 RowBox[{"Needs", "[", "\"\<WolframInstitute`Puzzles`\>\"", "]"}]], "Input", \
"ExampleInitialization",
 CellLabel->"In[1]:=",
 CellID->1969679695,ExpressionUUID->"c0e04a2a-d42f-4564-8279-fc9ca69a8780"],

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->
  "184d3fe6-e969-4af0-b690-47416e100738"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"3d3dd62d-7a19-4cf3-a88f-e2935107d3e6"],
 "Basic Examples",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(3)", "ExampleCount",ExpressionUUID->
  "1a059ea6-5144-4ff9-9bba-bfc0c37bb7f1"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->1565502232,ExpressionUUID->"026f6ac3-7aaf-4dc3-980c-758efc6b66ac"],

Cell["The chunks of a PNG the kernel just wrote:", "ExampleText",
 CellTags->
  "TextAnnotation",ExpressionUUID->"2997ec7b-b16d-494e-b0c2-5e6007a3311f"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Lookup", "[", 
  RowBox[{
   RowBox[{"ImageContainerChunks", "[", 
    RowBox[{"ExportByteArray", "[", 
     RowBox[{
      RowBox[{"Image", "[", 
       RowBox[{
        RowBox[{"Table", "[", 
         RowBox[{
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
        " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], "]"}],
    ",", " ", "\"\<Name\>\""}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"520191a8-e6e7-4cff-871e-8471e39a6ab4"],

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{"\<\"IHDR\"\>", ",", "\<\"eXIf\"\>", ",", "\<\"pHYs\"\>", 
   ",", "\<\"tEXt\"\>", ",", "\<\"tEXt\"\>", ",", "\<\"IDAT\"\>", 
   ",", "\<\"IEND\"\>"}], "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"abc300ff-6ae4-4353-81eb-c828372828d8"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "5581ae30-b7a2-4cf7-abea-1ff945f63bc7"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"cca97cbf-4199-4ec7-\
9bf5-d090c73f69f1"],

Cell["The whole table, with the payload bytes dropped so it fits:", \
"ExampleText",ExpressionUUID->"1087f174-db0a-4768-adb5-50507d3523b3"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Dataset", "[", 
  RowBox[{
   RowBox[{
    RowBox[{"KeyDrop", "[", 
     RowBox[{"#", ",", " ", "\"\<Data\>\""}], "]"}], " ", "&"}], " ", "/@", 
   " ", 
   RowBox[{"ImageContainerChunks", "[", 
    RowBox[{"ExportByteArray", "[", 
     RowBox[{
      RowBox[{"Image", "[", 
       RowBox[{
        RowBox[{"Table", "[", 
         RowBox[{
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
        " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], 
    "]"}]}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"dd983430-3d53-410b-a25f-fc74db2d33fa"],

Cell[BoxData[
 TagBox[
  TagBox[
   DynamicModuleBox[{TypeSystem`NestedGrid`PackagePrivate`$state$$ = <|
    "InitialData" -> {<|
       "Name" -> "IHDR", "Position" -> 8, "Length" -> 13, "CRCValid" -> 
        True|>, <|
       "Name" -> "eXIf", "Position" -> 33, "Length" -> 198, "CRCValid" -> 
        True|>, <|
       "Name" -> "pHYs", "Position" -> 243, "Length" -> 9, "CRCValid" -> 
        True|>, <|
       "Name" -> "tEXt", "Position" -> 264, "Length" -> 60, "CRCValid" -> 
        True|>, <|
       "Name" -> "tEXt", "Position" -> 336, "Length" -> 33, "CRCValid" -> 
        True|>, <|
       "Name" -> "IDAT", "Position" -> 381, "Length" -> 33, "CRCValid" -> 
        True|>, <|
       "Name" -> "IEND", "Position" -> 426, "Length" -> 0, "CRCValid" -> 
        True|>}, "AllowEmbedding" -> True, "InitialShape" -> 
     TypeSystem`PackageScope`HeaderShape[<|{All, "Name"} -> 
        1, {All, "Position"} -> 1, {All, "Length"} -> 1, {All, "CRCValid"} -> 
        1|>, 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          
          TypeSystem`PackageScope`RowShape[<|
           "Name" -> TypeSystem`PackageScope`AtomShape[44.800000000000004`], 
            "Position" -> TypeSystem`PackageScope`AtomShape[34], "Length" -> 
            TypeSystem`PackageScope`AtomShape[34], "CRCValid" -> 
            TypeSystem`PackageScope`AtomShape[36]|>], 
          DirectedInfinity[1], 4, {All}]], 7, 
        DirectedInfinity[1], {}]], "InitialType" -> TypeSystem`Vector[
       TypeSystem`Struct[{"Name", "Position", "Length", "CRCValid"}, {
         TypeSystem`Atom[String], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[TypeSystem`Boolean]}], 7], "Meta" -> <||>, 
     "RowTarget" -> 20, "ColumnTarget" -> 10, "Shape" -> 
     TypeSystem`PackageScope`HeaderShape[<|{All, "Name"} -> 
        1, {All, "Position"} -> 1, {All, "Length"} -> 1, {All, "CRCValid"} -> 
        1|>, 
       TypeSystem`PackageScope`Limited[
        TypeSystem`PackageScope`ColumnShape[
         TypeSystem`PackageScope`Limited[
          
          TypeSystem`PackageScope`RowShape[<|
           "Name" -> TypeSystem`PackageScope`AtomShape[44.800000000000004`], 
            "Position" -> TypeSystem`PackageScope`AtomShape[34], "Length" -> 
            TypeSystem`PackageScope`AtomShape[34], "CRCValid" -> 
            TypeSystem`PackageScope`AtomShape[36]|>], 
          DirectedInfinity[1], 4, {All}]], 7, 
        DirectedInfinity[1], {}]], "Type" -> TypeSystem`Vector[
       TypeSystem`Struct[{"Name", "Position", "Length", "CRCValid"}, {
         TypeSystem`Atom[String], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[Integer], 
         TypeSystem`Atom[TypeSystem`Boolean]}], 7], "Path" -> {}, 
     "DisplayedRowCount" -> 7, "DisplayedColumnCount" -> 4, "DataRowCount" -> 
     7, "DataColumnCount" -> 4, "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["Name", 
                  Style[
                  "Name", 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, "Name"}, 1]]], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                All, "Name"}, "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["Position", 
                  Style[
                  "Position", 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, "Position"}, 1]]], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                All, "Position"}, "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["Length", 
                  Style[
                  "Length", 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, "Length"}, 1]]], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                All, "Length"}, "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["CRCValid", 
                  Style[
                  "CRCValid", 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, "CRCValid"}, 1]]], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{
                All, "CRCValid"}, "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["IHDR", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["Name"]}, "Item", False], "Mouse"], 
              ImageSize -> {{44.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["8"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["Position"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["13"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["Length"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["True"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{1, 
                 Key["CRCValid"]}, "Item", False], "Mouse"], 
              ImageSize -> {{36, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["eXIf", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["Name"]}, "Item", False], "Mouse"], 
              ImageSize -> {{44.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["33"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["Position"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["198"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["Length"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["True"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{2, 
                 Key["CRCValid"]}, "Item", False], "Mouse"], 
              ImageSize -> {{36, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["pHYs", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["Name"]}, "Item", False], "Mouse"], 
              ImageSize -> {{44.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["243"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["Position"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["9"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["Length"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["True"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{3, 
                 Key["CRCValid"]}, "Item", False], "Mouse"], 
              ImageSize -> {{36, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["tEXt", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["Name"]}, "Item", False], "Mouse"], 
              ImageSize -> {{44.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["264"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["Position"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["60"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["Length"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["True"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{4, 
                 Key["CRCValid"]}, "Item", False], "Mouse"], 
              ImageSize -> {{36, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["tEXt", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{5, 
                 Key["Name"]}, "Item", False], "Mouse"], 
              ImageSize -> {{44.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["336"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{5, 
                 Key["Position"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["33"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{5, 
                 Key["Length"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["True"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{5, 
                 Key["CRCValid"]}, "Item", False], "Mouse"], 
              ImageSize -> {{36, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["IDAT", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{6, 
                 Key["Name"]}, "Item", False], "Mouse"], 
              ImageSize -> {{44.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["381"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{6, 
                 Key["Position"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["33"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{6, 
                 Key["Length"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["True"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{6, 
                 Key["CRCValid"]}, "Item", False], "Mouse"], 
              ImageSize -> {{36, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}]}, {
            Item[
             Pane[
              Annotation["IEND", 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{7, 
                 Key["Name"]}, "Item", False], "Mouse"], 
              ImageSize -> {{44.800000000000004`, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["426"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{7, 
                 Key["Position"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["0"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{7, 
                 Key["Length"]}, "Item", False], "Mouse"], 
              ImageSize -> {{34, Full}, Automatic}, 
              ImageMargins -> {{5, 3}, {4, 5}}], 
             ItemSize -> {Full, Automatic}], 
            Item[
             Pane[
              Annotation[
               RawBoxes["True"], 
               TypeSystem`NestedGrid`PackagePrivate`$SliceMarker[
                TypeSystem`NestedGrid`PackagePrivate`localHold[
                TypeSystem`NestedGrid`PackagePrivate`$outputID$$]][{7, 
                 Key["CRCValid"]}, "Item", False], "Mouse"], 
              ImageSize -> {{36, 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->{219.858, {104.245849609375, 109.536865234375}},
      TrackedSymbols:>{
       TypeSystem`NestedGrid`PackagePrivate`$state$$, 
        TypeSystem`NestedGrid`PackagePrivate`$grid$$}], 
     TypeSystem`NestedGrid`PackagePrivate`mouseAnnotation$$ = 
     MouseAnnotation[],
     ImageSizeCache->{219.858, {104.245849609375, 109.536865234375}}],
    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->"a181fb11-bdb6-4278-8c23-77239431340d"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "3c534a03-af36-499d-a3e8-c91b69e3c1d5"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"6f402cd6-26be-499c-\
a5f6-a08c4e057ba5"],

Cell["\<\
Every chunk's CRC agrees with its data, which is what a clean file looks like:\
\>", "ExampleText",ExpressionUUID->"e5467249-0040-43c8-8522-5b2b7a32417a"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Union", "[", 
  RowBox[{"Lookup", "[", 
   RowBox[{
    RowBox[{"ImageContainerChunks", "[", 
     RowBox[{"ExportByteArray", "[", 
      RowBox[{
       RowBox[{"Image", "[", 
        RowBox[{
         RowBox[{"Table", "[", 
          RowBox[{
           RowBox[{"{", 
            RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
           RowBox[{"{", 
            RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
           RowBox[{"{", 
            RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
         " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], 
     "]"}], ",", " ", "\"\<CRCValid\>\""}], "]"}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"a22bc011-3912-4c66-8474-18039c1d6047"],

Cell[BoxData[
 RowBox[{"{", "True", "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"1d25c454-29a2-4f17-be61-2a7c29f36c15"]
}, 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->
  "463648af-4806-4752-8eaf-5264e093fc18"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"b4feb3b0-c1c6-4823-af84-0e4afe35591c"],
 "Scope",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(4)", "ExampleCount",ExpressionUUID->
  "7756daab-248d-44a8-9ac1-71677e1a4aa8"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->1293636265,ExpressionUUID->"0cadf554-9954-4fa0-9f57-4d57eaa1ad1c"],

Cell["\<\
A JPEG is split into its marker segments, opening with SOI and closing with \
EOI:\
\>", "ExampleText",ExpressionUUID->"16386b08-9bf5-4ce9-8f91-e2808a793417"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Lookup", "[", 
  RowBox[{
   RowBox[{"ImageContainerChunks", "[", 
    RowBox[{"ExportByteArray", "[", 
     RowBox[{
      RowBox[{"Image", "[", 
       RowBox[{
        RowBox[{"Table", "[", 
         RowBox[{
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
        " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<JPEG\>\""}], "]"}], 
    "]"}], ",", " ", "\"\<Name\>\""}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"e727d745-d21c-4d54-a4db-c379ea5f0c48"],

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{"\<\"SOI\"\>", ",", "\<\"APP0\"\>", ",", "\<\"APP1\"\>", 
   ",", "\<\"DQT\"\>", ",", "\<\"DQT\"\>", ",", "\<\"SOF0\"\>", 
   ",", "\<\"DHT\"\>", ",", "\<\"DHT\"\>", ",", "\<\"DHT\"\>", 
   ",", "\<\"DHT\"\>", ",", "\<\"SOS\"\>", ",", "\<\"ECS\"\>", 
   ",", "\<\"EOI\"\>"}], "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"45ead49e-1664-4d5b-bd22-dee4b951007c"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "25be43ff-62b0-4442-ab0a-23294d9fa242"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"9147632a-09f3-4aac-\
b662-ab4cafe340f5"],

Cell["A marker's own code is reported next to its mnemonic:", "ExampleText",ExpressionUUID->"c18f63ad-7f17-46a6-b574-1b7e24d3a78e"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Lookup", "[", 
  RowBox[{
   RowBox[{"First", "[", 
    RowBox[{"ImageContainerChunks", "[", 
     RowBox[{"ExportByteArray", "[", 
      RowBox[{
       RowBox[{"Image", "[", 
        RowBox[{
         RowBox[{"Table", "[", 
          RowBox[{
           RowBox[{"{", 
            RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
           RowBox[{"{", 
            RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
           RowBox[{"{", 
            RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
         " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<JPEG\>\""}], "]"}], 
     "]"}], "]"}], ",", " ", 
   RowBox[{"{", 
    RowBox[{"\"\<Name\>\"", ",", " ", "\"\<Marker\>\""}], "}"}]}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"60736fa8-aec3-4996-9f0d-d880d5f56c19"],

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{"\<\"SOI\"\>", ",", "216"}], "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"86e94100-db97-4545-a227-185f8dcde591"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "a641224b-4577-4c87-be9c-1bf9ac119558"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"ed64f44b-b07a-4b38-\
bf6c-28d7d1e20ec4"],

Cell["\<\
A GIF is split into its blocks, closing with the one-byte trailer:\
\>", "ExampleText",ExpressionUUID->"a250427c-ad94-4fbf-9315-0dceb79de570"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Lookup", "[", 
  RowBox[{
   RowBox[{"ImageContainerChunks", "[", 
    RowBox[{"ExportByteArray", "[", 
     RowBox[{
      RowBox[{"Image", "[", 
       RowBox[{
        RowBox[{"Table", "[", 
         RowBox[{
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
          RowBox[{"{", 
           RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
        " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<GIF\>\""}], "]"}], "]"}],
    ",", " ", "\"\<Name\>\""}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"dadbd446-434c-4dd0-bd32-74d4a5af009c"],

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{"\<\"Header\"\>", ",", "\<\"LogicalScreenDescriptor\"\>", 
   ",", "\<\"GlobalColorTable\"\>", ",", "\<\"ApplicationExtension\"\>", 
   ",", "\<\"GraphicControlExtension\"\>", ",", "\<\"ImageDescriptor\"\>", 
   ",", "\<\"Trailer\"\>"}], "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"270c5f27-d698-4d70-ba86-db53406162d8"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "e5608911-a259-4985-b560-384e60557564"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"cbc805ff-cef3-4d3b-\
9ea6-323d88dfad45"],

Cell["\<\
A chunk's payload comes back as bytes, so it can be read directly. The GIF \
header spells its version:\
\>", "ExampleText",ExpressionUUID->"a1894cdb-4ca9-45bf-ab4d-cee335ffc260"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"ByteArrayToString", "[", 
  RowBox[{"Lookup", "[", 
   RowBox[{
    RowBox[{"First", "[", 
     RowBox[{"ImageContainerChunks", "[", 
      RowBox[{"ExportByteArray", "[", 
       RowBox[{
        RowBox[{"Image", "[", 
         RowBox[{
          RowBox[{"Table", "[", 
           RowBox[{
            RowBox[{"{", 
             RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
            RowBox[{"{", 
             RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
            RowBox[{"{", 
             RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
          " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<GIF\>\""}], "]"}], 
      "]"}], "]"}], ",", " ", "\"\<Data\>\""}], "]"}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"a9f71726-c785-44c4-a65c-43c3457968ad"],

Cell[BoxData["\<\"GIF89a\"\>"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"ccfd9413-2222-4a7c-a2ac-7b50c50be1ce"]
}, 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->
  "e5c7031d-fa8d-45e4-9387-ac1840f036bf"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"cbbd6bb8-ea6a-4735-9a49-a6c9c47ccecd"],
 "Applications",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(2)", "ExampleCount",ExpressionUUID->
  "f04ebd59-2001-45e8-9043-86673209c47d"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->258228157,ExpressionUUID->"0405b389-456f-42dd-bf41-b61462229fe4"],

Cell["\<\
The IHDR payload of a PNG carries the width and height as four-byte \
big-endian integers:\
\>", "ExampleText",ExpressionUUID->"2cb8daf5-d208-4c58-992e-816a4ccb6d36"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"FromDigits", "[", 
  RowBox[{
   RowBox[{"Take", "[", 
    RowBox[{
     RowBox[{"Normal", "[", 
      RowBox[{"Lookup", "[", 
       RowBox[{
        RowBox[{"First", "[", 
         RowBox[{"ImageContainerChunks", "[", 
          RowBox[{"ExportByteArray", "[", 
           RowBox[{
            RowBox[{"Image", "[", 
             RowBox[{
              RowBox[{"Table", "[", 
               RowBox[{
                RowBox[{"{", 
                 RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", 
                " ", 
                RowBox[{"{", 
                 RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
                RowBox[{"{", 
                 RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
              " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], 
          "]"}], "]"}], ",", " ", "\"\<Data\>\""}], "]"}], "]"}], ",", " ", 
     "4"}], "]"}], ",", " ", "256"}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"e3516cde-5a7a-4066-9337-06bfbac4d3a8"],

Cell[BoxData["16"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"6abc7153-c26f-433b-b003-9f34f2067359"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "43a61ccb-86d1-4186-8502-9d3e410efe61"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"ba0b149b-3817-4e22-\
8cdd-4735ebd3d327"],

Cell["\<\
Flipping one byte of a chunk's data breaks only that chunk's checksum, which \
is how tampering shows up:\
\>", "ExampleText",ExpressionUUID->"bef54ad3-6cc7-430a-b357-211eaf68aa94"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Lookup", "[", 
  RowBox[{
   RowBox[{"ImageContainerChunks", "[", 
    RowBox[{"ByteArray", "[", 
     RowBox[{"MapAt", "[", 
      RowBox[{
       RowBox[{
        RowBox[{"BitXor", "[", 
         RowBox[{"#", ",", " ", "1"}], "]"}], " ", "&"}], ",", " ", 
       RowBox[{"Normal", "[", 
        RowBox[{"ExportByteArray", "[", 
         RowBox[{
          RowBox[{"Image", "[", 
           RowBox[{
            RowBox[{"Table", "[", 
             RowBox[{
              RowBox[{"{", 
               RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
              RowBox[{"{", 
               RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
              RowBox[{"{", 
               RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
            " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], 
        "]"}], ",", " ", "20"}], "]"}], "]"}], "]"}], ",", 
   " ", "\"\<CRCValid\>\""}], "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"7c405277-b736-4b61-88ef-ff127bc3679e"],

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{
  "False", ",", "True", ",", "True", ",", "True", ",", "True", ",", "True", ",",
    "True"}], "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"f4bd914c-6a91-48c0-b728-42d286584e44"]
}, 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->
  "9a684b94-8db1-43fd-937d-8629e71cad91"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"2b5bc329-72b2-431d-a81b-b7ba75a79447"],
 "Properties & Relations",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(2)", "ExampleCount",ExpressionUUID->
  "0b645db7-bd7b-4db3-b680-cb0694c6508d"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->2123667759,ExpressionUUID->"da616ec0-c0dd-460a-b709-4dcdaa17871d"],

Cell[TextData[{
 "The container's units account for the whole file when nothing has been \
appended, so ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["ImageAppendedData"]], 
    "paclet:WolframInstitute/Puzzles/ref/ImageAppendedData", 
    "WolframInstitute/Puzzles Package Symbol"},
   "PackageLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "d28aa4ba-f95e-4ca5-9e6b-d097daf6e423"],
 " comes back empty:"
}], "ExampleText",ExpressionUUID->"b55a8fac-63c5-4b0d-a486-b5cf409277ae"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Length", "[", 
  RowBox[{"ImageAppendedData", "[", 
   RowBox[{"ExportByteArray", "[", 
    RowBox[{
     RowBox[{"Image", "[", 
      RowBox[{
       RowBox[{"Table", "[", 
        RowBox[{
         RowBox[{"{", 
          RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
         RowBox[{"{", 
          RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
         RowBox[{"{", 
          RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
       " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], "]"}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"0a10a3af-f534-4333-82b2-a0a7cc0f64b1"],

Cell[BoxData["0"], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"13c322ba-83dd-4d5e-bed5-c6c568f770c1"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "08993793-7a53-4047-abf3-4ac374605f09"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"9be3af0a-db22-4d58-\
9951-2027d07e1631"],

Cell[TextData[{
 "The text chunks this reports are the ones ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["ImageTextMetadata"]], 
    "paclet:WolframInstitute/Puzzles/ref/ImageTextMetadata", 
    "WolframInstitute/Puzzles Package Symbol"},
   "PackageLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",
  FontSize->0.9 Inherited,ExpressionUUID->
  "95f52bb6-8c9f-4e1e-8d1e-d4003c773e49"],
 " reads:"
}], "ExampleText",ExpressionUUID->"67978ad6-9ced-446a-b575-2ed0edc875d7"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Keys", "[", 
  RowBox[{"ImageTextMetadata", "[", 
   RowBox[{"ExportByteArray", "[", 
    RowBox[{
     RowBox[{"Image", "[", 
      RowBox[{
       RowBox[{"Table", "[", 
        RowBox[{
         RowBox[{"{", 
          RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
         RowBox[{"{", 
          RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
         RowBox[{"{", 
          RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
       " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], "]"}], 
  "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"9edd1b18-9a9a-4d3d-8720-fdb9c6a73a8d"],

Cell[BoxData[
 RowBox[{"{", 
  RowBox[{"\<\"Comments/Software\"\>", 
   ",", "\<\"Exif/Image/ResolutionUnit\"\>", 
   ",", "\<\"Exif/Image/Software\"\>"}], "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"d28f0f42-3073-4ac4-b44c-793c20d8fb9b"]
}, 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->
  "a5573bef-4142-4d9b-b461-d7b8f51855b9"],
 Cell[BoxData[
  TemplateBox[{1},
   "Spacer1"]],ExpressionUUID->"83f8da3d-7e94-4d62-865d-d79171ad587b"],
 "Possible Issues",
 "\[NonBreakingSpace]\[NonBreakingSpace]",
 Cell["(3)", "ExampleCount",ExpressionUUID->
  "e1f20bef-2510-494a-ab14-c65aa897f954"]
}], "ExampleSection", "ExampleSection",
 WholeCellGroupOpener->True,
 CacheGraphics->False,
 CellID->1305812373,ExpressionUUID->"1f618359-47d9-4ad9-a71e-27e8946b8bcd"],

Cell[TextData[{
 "A file that is not one of the three containers gives a ",
 Cell[BoxData[
  TemplateBox[{
    Cell[
     TextData["Failure"]], "paclet:ref/Failure"},
   "RefLink",
   BaseStyle->"InlineFormula"]], "InlineFormula",
  FontFamily->"Source Sans Pro",ExpressionUUID->
  "eece9f9a-f0c7-4dbf-933d-eb1099b75a30"],
 ", because the function read the bytes and could not go on:"
}], "ExampleText",ExpressionUUID->"05e5435c-a41b-43df-8eb4-643ffeb314cd"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"ImageContainerChunks", "[", 
  RowBox[{"ByteArray", "[", 
   RowBox[{
   "ToCharacterCode", "[", "\"\<BM this is not a container\>\"", "]"}], "]"}],
   "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"42a6ee2d-9555-4c79-b32d-79a166337c0e"],

Cell[BoxData[
 InterpretationBox[
  RowBox[{
   TagBox["Failure",
    "SummaryHead"], "[", 
   DynamicModuleBox[{Typeset`open$$ = False, Typeset`embedState$$ = "Ready"}, 
    
    TemplateBox[{
      PaneSelectorBox[{False -> GridBox[{{
            PaneBox[
             ButtonBox[
              DynamicBox[
               FEPrivate`FrontEndResource["FEBitmaps", "SummaryBoxOpener"]], 
              ButtonFunction :> (Typeset`open$$ = True), Appearance -> None, 
              BaseStyle -> {}, Evaluator -> Automatic, Method -> 
              "Preemptive"], Alignment -> {Center, Center}, ImageSize -> 
             Dynamic[{
               Automatic, 
                3.5 (CurrentValue["FontCapHeight"]/AbsoluteCurrentValue[
                 Magnification])}]], 
            FrameBox[
             StyleBox["\"\[WarningSign]\"", 
              Directive["Message", 35], StripOnInput -> False], 
             ContentPadding -> False, FrameStyle -> None, 
             FrameMargins -> {{0, 0}, {0, 0}}, StripOnInput -> False], 
            GridBox[{{
               TagBox[
                GridBox[{{
                   TagBox["\"Message: \"", "SummaryItemAnnotation"], 
                   "\[InvisibleSpace]", 
                   TagBox[
                   "\"the source is not a PNG, JPEG or GIF container.\"", 
                    "SummaryItem"]}}, 
                 GridBoxItemSize -> {"Columns" -> {6.5, All, Automatic}}, 
                 GridBoxAlignment -> {"Columns" -> {{Left}}}, 
                 GridBoxSpacings -> {"Columns" -> {{0}}}], "SummaryItem"]}, {
               TagBox[
                GridBox[{{
                   TagBox["\"Tag: \"", "SummaryItemAnnotation"], 
                   "\[InvisibleSpace]", 
                   TagBox["\"ConfirmationFailed\"", "SummaryItem"]}}, 
                 GridBoxItemSize -> {"Columns" -> {6.5, All, Automatic}}, 
                 GridBoxAlignment -> {"Columns" -> {{Left}}}, 
                 GridBoxSpacings -> {"Columns" -> {{0}}}], "SummaryItem"]}}, 
             GridBoxAlignment -> {
              "Columns" -> {{Left}}, "Rows" -> {{Automatic}}}, AutoDelete -> 
             False, GridBoxItemSize -> {
              "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}, 
             GridBoxSpacings -> {"Columns" -> {{2}}, "Rows" -> {{Automatic}}},
              BaseStyle -> {
              ShowStringCharacters -> False, NumberMarks -> False, 
               PrintPrecision -> 3, ShowSyntaxStyles -> False}]}}, 
          GridBoxAlignment -> {"Columns" -> {{Left}}, "Rows" -> {{Top}}}, 
          AutoDelete -> False, 
          GridBoxItemSize -> {
           "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}, 
          BaselinePosition -> {1, 1}], True -> GridBox[{{
            PaneBox[
             ButtonBox[
              DynamicBox[
               FEPrivate`FrontEndResource["FEBitmaps", "SummaryBoxCloser"]], 
              ButtonFunction :> (Typeset`open$$ = False), Appearance -> None, 
              BaseStyle -> {}, Evaluator -> Automatic, Method -> 
              "Preemptive"], Alignment -> {Center, Center}, ImageSize -> 
             Dynamic[{
               Automatic, 
                3.5 (CurrentValue["FontCapHeight"]/AbsoluteCurrentValue[
                 Magnification])}]], 
            FrameBox[
             StyleBox["\"\[WarningSign]\"", 
              Directive["Message", 35], StripOnInput -> False], 
             ContentPadding -> False, FrameStyle -> None, 
             FrameMargins -> {{0, 0}, {0, 0}}, StripOnInput -> False], 
            GridBox[{{
               TagBox[
                GridBox[{{
                   TagBox["\"Message: \"", "SummaryItemAnnotation"], 
                   "\[InvisibleSpace]", 
                   TagBox[
                   "\"the source is not a PNG, JPEG or GIF container.\"", 
                    "SummaryItem"]}}, 
                 GridBoxItemSize -> {"Columns" -> {6.5, All, Automatic}}, 
                 GridBoxAlignment -> {"Columns" -> {{Left}}}, 
                 GridBoxSpacings -> {"Columns" -> {{0}}}], "SummaryItem"]}, {
               TagBox[
                GridBox[{{
                   TagBox["\"Tag: \"", "SummaryItemAnnotation"], 
                   "\[InvisibleSpace]", 
                   TagBox["\"ConfirmationFailed\"", "SummaryItem"]}}, 
                 GridBoxItemSize -> {"Columns" -> {6.5, All, Automatic}}, 
                 GridBoxAlignment -> {"Columns" -> {{Left}}}, 
                 GridBoxSpacings -> {"Columns" -> {{0}}}], "SummaryItem"]}, {
               RowBox[{
                 TagBox[
                  
                  TemplateBox[{"\"ConfirmationType\"", "\": \""}, 
                   "RowDefault"], "SummaryItemAnnotation"], 
                 "\[InvisibleSpace]", 
                 TagBox[
                  TagBox["\"ConfirmBy\"", HoldForm], "SummaryItem"]}]}, {
               RowBox[{
                 TagBox[
                  TemplateBox[{"\"Expression\"", "\": \""}, "RowDefault"], 
                  "SummaryItemAnnotation"], "\[InvisibleSpace]", 
                 TagBox[
                  TagBox[
                   RowBox[{"Missing", "[", "\"UnrecognizedContainer\"", "]"}],
                    HoldForm], "SummaryItem"]}]}, {
               RowBox[{
                 TagBox[
                  TemplateBox[{"\"Information\"", "\": \""}, "RowDefault"], 
                  "SummaryItemAnnotation"], "\[InvisibleSpace]", 
                 TagBox[
                  TagBox[
                  "\"the source is not a PNG, JPEG or GIF container.\"", 
                   HoldForm], "SummaryItem"]}]}, {
               RowBox[{
                 TagBox[
                  TemplateBox[{"\"Function\"", "\": \""}, "RowDefault"], 
                  "SummaryItemAnnotation"], "\[InvisibleSpace]", 
                 TagBox[
                  TagBox["StringQ", HoldForm], "SummaryItem"]}]}}, 
             GridBoxAlignment -> {
              "Columns" -> {{Left}}, "Rows" -> {{Automatic}}}, AutoDelete -> 
             False, GridBoxItemSize -> {
              "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}, 
             GridBoxSpacings -> {"Columns" -> {{2}}, "Rows" -> {{Automatic}}},
              BaseStyle -> {
              ShowStringCharacters -> False, NumberMarks -> False, 
               PrintPrecision -> 3, ShowSyntaxStyles -> False}]}}, 
          GridBoxAlignment -> {"Columns" -> {{Left}}, "Rows" -> {{Top}}}, 
          AutoDelete -> False, 
          GridBoxItemSize -> {
           "Columns" -> {{Automatic}}, "Rows" -> {{Automatic}}}, 
          BaselinePosition -> {1, 1}]}, 
       Dynamic[Typeset`open$$], ImageSize -> Automatic]},
     "SummaryPanel"],
    DynamicModuleValues:>{}], "]"}],
  Failure[
  "ConfirmationFailed", <|
   "MessageTemplate" -> "the source is not a PNG, JPEG or GIF container.", 
    "MessageParameters" -> {}, "ConfirmationType" -> "ConfirmBy", 
    "Expression" :> Missing["UnrecognizedContainer"], "Information" -> 
    "the source is not a PNG, JPEG or GIF container.", "Function" -> 
    StringQ|>],
  Editable->False,
  SelectWithContents->True,
  Selectable->False]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"93cf615d-c116-4fbc-af11-170076cdcba8"]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "11b51958-c9dd-456c-be9f-8c47f66a3a33"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"b42af256-4669-42f9-\
81ea-141a0e8973f7"],

Cell["\<\
Something that is not a source at all is returned unevaluated:\
\>", "ExampleText",ExpressionUUID->"4f667adc-908f-43ea-8125-3380b5d00e34"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"ImageContainerChunks", "[", "42", "]"}]], "Input",
 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"ef0af6f7-ce7d-4022-b22e-bb322c9cf8e7"],

Cell[BoxData[
 RowBox[{"ImageContainerChunks", "[", "42", "]"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"7cb45de9-767a-495c-94d8-2ef48fba0c5c"]
}, Open  ]]
}, Open  ]],

Cell[CellGroupData[{

Cell[BoxData[
 InterpretationBox[Cell[
  "\t", "ExampleDelimiter",ExpressionUUID->
   "42f36519-61d0-45f5-91f8-68de5beaab83"],
  $Line = 0; Null]], "ExampleDelimiter",ExpressionUUID->"8a9cde25-f2db-4f79-\
b3d9-71bfd148b804"],

Cell["\<\
A truncated container stops the parse where the truncation is, rather than \
failing: the units read so far are still returned:\
\>", "ExampleText",ExpressionUUID->"bed11686-8480-49a4-8daa-1e633f936823"],

Cell[CellGroupData[{

Cell[BoxData[
 RowBox[{"Lookup", "[", 
  RowBox[{
   RowBox[{"ImageContainerChunks", "[", 
    RowBox[{"Take", "[", 
     RowBox[{
      RowBox[{"ExportByteArray", "[", 
       RowBox[{
        RowBox[{"Image", "[", 
         RowBox[{
          RowBox[{"Table", "[", 
           RowBox[{
            RowBox[{"{", 
             RowBox[{"i", ",", " ", "j", ",", " ", "128"}], "}"}], ",", " ", 
            RowBox[{"{", 
             RowBox[{"i", ",", " ", "16"}], "}"}], ",", " ", 
            RowBox[{"{", 
             RowBox[{"j", ",", " ", "16"}], "}"}]}], "]"}], ",", 
          " ", "\"\<Byte\>\""}], "]"}], ",", " ", "\"\<PNG\>\""}], "]"}], ",",
       " ", "120"}], "]"}], "]"}], ",", " ", "\"\<Name\>\""}], "]"}]], "Input",\

 CellProlog:>Needs["WolframInstitute`Puzzles`"],
 CellLabel->"In[1]:=",ExpressionUUID->"b9a62700-fe9a-423b-bba2-041e25cb42aa"],

Cell[BoxData[
 RowBox[{"{", "\<\"IHDR\"\>", "}"}]], "Output",
 CellLabel->"Out[1]= ",ExpressionUUID->"476036a1-2f4b-4f68-8bab-6662bc9b4148"]
}, 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["ImageAppendedData"]], 
           "paclet:WolframInstitute/Puzzles/ref/ImageAppendedData", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "2259b993-2a69-4b18-acbd-5bf746af5b33"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["ImageTextMetadata"]], 
           "paclet:WolframInstitute/Puzzles/ref/ImageTextMetadata", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "b517369a-6c11-447b-a117-ed02746b9696"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["EmbeddedFileSignatures"]], 
           "paclet:WolframInstitute/Puzzles/ref/EmbeddedFileSignatures", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "cf85736b-4671-43d0-9a15-0bd5a0190989"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["SteganographySurvey"]], 
           "paclet:WolframInstitute/Puzzles/ref/SteganographySurvey", 
           "WolframInstitute/Puzzles Package Symbol"},
          "PackageLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "b25af447-823a-4830-b504-9ce565aa5c4f"],
        "\[NonBreakingSpace]",
        StyleBox[
        "\[MediumSpace]\[FilledVerySmallSquare]\[MediumSpace]", 
         "InlineSeparator"],
        " ",
        Cell[BoxData[
         TemplateBox[{
           Cell[
            TextData["Import"]], "paclet:ref/Import"},
          "RefLink",
          BaseStyle->"InlineFormula"]], "InlineFormula",
         FontFamily->"Source Sans Pro",ExpressionUUID->
         "d3c292c3-623c-4ddb-a74a-3d4a0873d5db"]
       }], "SeeAlso",ExpressionUUID->"0eeb27d0-9a56-4cd5-b352-9b3281053ed8"]}
     }]}
  }]], "SeeAlsoSection",ExpressionUUID->"15d2a3d3-7c2b-4df6-a5cc-\
282a6165fb79"],

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["Steganography"]], 
           "paclet:WolframInstitute/Puzzles/guide/Steganography"},
          "RefLinkPlain",
          BaseStyle->{"MoreAbout"}]], "MoreAbout",ExpressionUUID->
         "dd1216ac-4db5-4cd6-a28a-077561ff0ff5"]}]}
     }]}
  }]], "MoreAboutSection",ExpressionUUID->"21c924d8-4b6a-46f3-ac19-\
b0c75fe9de77"],

Cell[" ", "FooterCell",ExpressionUUID->"ea013728-40b2-4f19-b3df-05288fc4f933"]
},
Saveable->False,
ScreenStyleEnvironment->"Working",
WindowSize->{900, 830},
WindowMargins->{{0, Automatic}, {Automatic, 0}},
WindowTitle->"ImageContainerChunks",
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, 45.021320}", 
    "history" -> {"XX", "", "", ""}, "context" -> "WolframInstitute`Puzzles`",
     "keywords" -> {}, "specialkeywords" -> {}, 
    "tutorialcollectionlinks" -> {}, "index" -> True, "label" -> 
    "Wolfram Institute/ Puzzles Symbol", "language" -> "en", "paclet" -> 
    "WolframInstitute/Puzzles", "status" -> "None", "summary" -> 
    "PackageLink[ImageContainerChunks, paclet : \
WolframInstitute/Puzzles/ref/ImageContainerChunks, WolframInstitute/Puzzles \
Package Symbol][source] gives the structural units of an image container as a \
list of Associations.", "synonyms" -> {}, "tabletags" -> {}, "title" -> 
    "ImageContainerChunks", "titlemodifier" -> "", "metadescription" -> "", 
    "windowtitle" -> "ImageContainerChunks", "type" -> "Symbol", "uri" -> 
    "WolframInstitute/Puzzles/ref/ImageContainerChunks", "WorkflowDockedCell" -> 
    ""}, "SearchTextTranslated" -> ""},
CellContext->CellGroup,
FrontEndVersion->"15.0 for Mac OS X ARM (64-bit) (May 19, 2026)",
StyleDefinitions->FrontEnd`FileName[{"Wolfram"}, "Reference.nb"],
ExpressionUUID->"fbdad9ad-6291-4301-9cb2-f8f3212c8f83"
]
(* End of Notebook Content *)

(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{
 "TextAnnotation"->{
  Cell[17931, 483, 152, 2, 70, "ExampleText",ExpressionUUID->"2997ec7b-b16d-494e-b0c2-5e6007a3311f",
   CellTags->"TextAnnotation"]}
 }
*)
(*CellTagsIndex
CellTagsIndex->{
 {"TextAnnotation", 98364, 2323}
 }
*)
(*NotebookFileOutline
Notebook[{
Cell[588, 21, 6361, 153, 70, "AnchorBarGrid",ExpressionUUID->"47e9f318-19be-47c2-9372-7360b00b4198",
 CellID->1],
Cell[6952, 176, 107, 0, 70, "ContextNameCell",ExpressionUUID->"dfc8288d-1431-4282-abfc-80cf5366312c"],
Cell[CellGroupData[{
Cell[7084, 180, 563, 14, 70, "ObjectNameGrid",ExpressionUUID->"8e02c5e3-344c-469e-b125-5a2a0b449ea1"],
Cell[7650, 196, 785, 19, 70, "Usage",ExpressionUUID->"3c2922eb-439a-4e8d-b737-9e92675801da"]
}, Open  ]],
Cell[CellGroupData[{
Cell[8472, 220, 1444, 34, 70, "NotesSection",ExpressionUUID->"ea9f2716-fb6d-480a-be29-f1c69b129294",
 CellGroupingRules->{"SectionGrouping", 50},
 CellID->1268181061],
Cell[9919, 256, 643, 21, 70, "Notes",ExpressionUUID->"f6c3c7c1-5463-43d2-ba17-a671ee6b9f4a"],
Cell[10565, 279, 1116, 31, 70, "Notes",ExpressionUUID->"b1e5ad9a-ddcb-4380-83f2-e95f75609562"],
Cell[11684, 312, 392, 8, 70, "Notes",ExpressionUUID->"f2793d3b-a3ac-45db-9f11-336f3cd348e1"],
Cell[12079, 322, 590, 13, 70, "Notes",ExpressionUUID->"adfc19c6-6991-406b-af99-c661ad4e02a5"],
Cell[12672, 337, 1097, 27, 70, "Notes",ExpressionUUID->"d871618e-ecd2-4a2c-9663-a8b957279d7e"],
Cell[13772, 366, 611, 15, 70, "Notes",ExpressionUUID->"55ad1827-01dd-4eda-8e79-1dbb8b3884db"],
Cell[14386, 383, 541, 13, 70, "Notes",ExpressionUUID->"b096dbed-7323-442d-b6f6-fa3afe1a9f83"]
}, Closed]],
Cell[14942, 399, 80, 0, 70, "PageDelimiter",ExpressionUUID->"cd334b28-dec1-42bf-a83e-499d59f005cc"],
Cell[CellGroupData[{
Cell[15047, 403, 1401, 37, 70, "PrimaryExamplesSection",ExpressionUUID->"bd8b9447-80dc-4108-ba80-392426635537",
 CellID->543895752],
Cell[16451, 442, 216, 4, 70, "Input",ExpressionUUID->"c0e04a2a-d42f-4564-8279-fc9ca69a8780",
 CellID->1969679695],
Cell[CellGroupData[{
Cell[16692, 450, 1236, 31, 70, "ExampleSection",ExpressionUUID->"026f6ac3-7aaf-4dc3-980c-758efc6b66ac",
 CellID->1565502232],
Cell[17931, 483, 152, 2, 70, "ExampleText",ExpressionUUID->"2997ec7b-b16d-494e-b0c2-5e6007a3311f",
 CellTags->"TextAnnotation"],
Cell[CellGroupData[{
Cell[18108, 489, 762, 19, 70, "Input",ExpressionUUID->"520191a8-e6e7-4cff-871e-8471e39a6ab4"],
Cell[18873, 510, 287, 5, 70, "Output",ExpressionUUID->"abc300ff-6ae4-4353-81eb-c828372828d8"]
}, Open  ]],
Cell[CellGroupData[{
Cell[19197, 520, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"cca97cbf-4199-4ec7-9bf5-d090c73f69f1"],
Cell[19424, 527, 139, 1, 70, "ExampleText",ExpressionUUID->"1087f174-db0a-4768-adb5-50507d3523b3"],
Cell[CellGroupData[{
Cell[19588, 532, 865, 23, 70, "Input",ExpressionUUID->"dd983430-3d53-410b-a25f-fc74db2d33fa"],
Cell[20456, 557, 42822, 816, 70, "Output",ExpressionUUID->"a181fb11-bdb6-4278-8c23-77239431340d"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[63327, 1379, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"6f402cd6-26be-499c-a5f6-a08c4e057ba5"],
Cell[63554, 1386, 164, 2, 70, "ExampleText",ExpressionUUID->"e5467249-0040-43c8-8522-5b2b7a32417a"],
Cell[CellGroupData[{
Cell[63743, 1392, 815, 20, 70, "Input",ExpressionUUID->"a22bc011-3912-4c66-8474-18039c1d6047"],
Cell[64561, 1414, 132, 2, 70, "Output",ExpressionUUID->"1d25c454-29a2-4f17-be61-2a7c29f36c15"]
}, Open  ]]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[64754, 1423, 1227, 31, 70, "ExampleSection",ExpressionUUID->"0cadf554-9954-4fa0-9f57-4d57eaa1ad1c",
 CellID->1293636265],
Cell[65984, 1456, 168, 3, 70, "ExampleText",ExpressionUUID->"16386b08-9bf5-4ce9-8f91-e2808a793417"],
Cell[CellGroupData[{
Cell[66177, 1463, 764, 19, 70, "Input",ExpressionUUID->"e727d745-d21c-4d54-a4db-c379ea5f0c48"],
Cell[66944, 1484, 411, 7, 70, "Output",ExpressionUUID->"45ead49e-1664-4d5b-bd22-dee4b951007c"]
}, Open  ]],
Cell[CellGroupData[{
Cell[67392, 1496, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"9147632a-09f3-4aac-b662-ab4cafe340f5"],
Cell[67619, 1503, 131, 0, 70, "ExampleText",ExpressionUUID->"c18f63ad-7f17-46a6-b574-1b7e24d3a78e"],
Cell[CellGroupData[{
Cell[67775, 1507, 882, 23, 70, "Input",ExpressionUUID->"60736fa8-aec3-4996-9f0d-d880d5f56c19"],
Cell[68660, 1532, 164, 3, 70, "Output",ExpressionUUID->"86e94100-db97-4545-a227-185f8dcde591"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[68873, 1541, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"ed64f44b-b07a-4b38-bf6c-28d7d1e20ec4"],
Cell[69100, 1548, 152, 2, 70, "ExampleText",ExpressionUUID->"a250427c-ad94-4fbf-9315-0dceb79de570"],
Cell[CellGroupData[{
Cell[69277, 1554, 762, 19, 70, "Input",ExpressionUUID->"dadbd446-434c-4dd0-bd32-74d4a5af009c"],
Cell[70042, 1575, 373, 6, 70, "Output",ExpressionUUID->"270c5f27-d698-4d70-ba86-db53406162d8"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[70464, 1587, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"cbc805ff-cef3-4d3b-9ea6-323d88dfad45"],
Cell[70691, 1594, 189, 3, 70, "ExampleText",ExpressionUUID->"a1894cdb-4ca9-45bf-ab4d-cee335ffc260"],
Cell[CellGroupData[{
Cell[70905, 1601, 872, 21, 70, "Input",ExpressionUUID->"a9f71726-c785-44c4-a65c-43c3457968ad"],
Cell[71780, 1624, 120, 1, 70, "Output",ExpressionUUID->"ccfd9413-2222-4a7c-a2ac-7b50c50be1ce"]
}, Open  ]]
}, Open  ]]
}, Closed]],
Cell[CellGroupData[{
Cell[71961, 1632, 1233, 31, 70, "ExampleSection",ExpressionUUID->"0405b389-456f-42dd-bf41-b61462229fe4",
 CellID->258228157],
Cell[73197, 1665, 176, 3, 70, "ExampleText",ExpressionUUID->"2cb8daf5-d208-4c58-992e-816a4ccb6d36"],
Cell[CellGroupData[{
Cell[73398, 1672, 1088, 27, 70, "Input",ExpressionUUID->"e3516cde-5a7a-4066-9337-06bfbac4d3a8"],
Cell[74489, 1701, 108, 1, 70, "Output",ExpressionUUID->"6abc7153-c26f-433b-b003-9f34f2067359"]
}, Open  ]],
Cell[CellGroupData[{
Cell[74634, 1707, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"ba0b149b-3817-4e22-8cdd-4735ebd3d327"],
Cell[74861, 1714, 191, 3, 70, "ExampleText",ExpressionUUID->"bef54ad3-6cc7-430a-b357-211eaf68aa94"],
Cell[CellGroupData[{
Cell[75077, 1721, 1088, 27, 70, "Input",ExpressionUUID->"7c405277-b736-4b61-88ef-ff127bc3679e"],
Cell[76168, 1750, 231, 5, 70, "Output",ExpressionUUID->"f4bd914c-6a91-48c0-b728-42d286584e44"]
}, Open  ]]
}, Open  ]]
}, Closed]],
Cell[CellGroupData[{
Cell[76460, 1762, 1244, 31, 70, "ExampleSection",ExpressionUUID->"da616ec0-c0dd-460a-b709-4dcdaa17871d",
 CellID->2123667759],
Cell[77707, 1795, 578, 15, 70, "ExampleText",ExpressionUUID->"b55a8fac-63c5-4b0d-a486-b5cf409277ae"],
Cell[CellGroupData[{
Cell[78310, 1814, 705, 18, 70, "Input",ExpressionUUID->"0a10a3af-f534-4333-82b2-a0a7cc0f64b1"],
Cell[79018, 1834, 107, 1, 70, "Output",ExpressionUUID->"13c322ba-83dd-4d5e-bed5-c6c568f770c1"]
}, Open  ]],
Cell[CellGroupData[{
Cell[79162, 1840, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"9be3af0a-db22-4d58-9951-2027d07e1631"],
Cell[79389, 1847, 523, 14, 70, "ExampleText",ExpressionUUID->"67978ad6-9ced-446a-b575-2ed0edc875d7"],
Cell[CellGroupData[{
Cell[79937, 1865, 703, 18, 70, "Input",ExpressionUUID->"9edd1b18-9a9a-4d3d-8720-fdb9c6a73a8d"],
Cell[80643, 1885, 252, 5, 70, "Output",ExpressionUUID->"d28f0f42-3073-4ac4-b44c-793c20d8fb9b"]
}, Open  ]]
}, Open  ]]
}, Closed]],
Cell[CellGroupData[{
Cell[80956, 1897, 1237, 31, 70, "ExampleSection",ExpressionUUID->"1f618359-47d9-4ad9-a71e-27e8946b8bcd",
 CellID->1305812373],
Cell[82196, 1930, 458, 11, 70, "ExampleText",ExpressionUUID->"05e5435c-a41b-43df-8eb4-643ffeb314cd"],
Cell[CellGroupData[{
Cell[82679, 1945, 319, 7, 70, "Input",ExpressionUUID->"42a6ee2d-9555-4c79-b32d-79a166337c0e"],
Cell[83001, 1954, 7202, 148, 70, "Output",ExpressionUUID->"93cf615d-c116-4fbc-af11-170076cdcba8"]
}, Open  ]],
Cell[CellGroupData[{
Cell[90240, 2107, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"b42af256-4669-42f9-81ea-141a0e8973f7"],
Cell[90467, 2114, 148, 2, 70, "ExampleText",ExpressionUUID->"4f667adc-908f-43ea-8125-3380b5d00e34"],
Cell[CellGroupData[{
Cell[90640, 2120, 201, 3, 70, "Input",ExpressionUUID->"ef0af6f7-ce7d-4022-b22e-bb322c9cf8e7"],
Cell[90844, 2125, 154, 2, 70, "Output",ExpressionUUID->"7cb45de9-767a-495c-94d8-2ef48fba0c5c"]
}, Open  ]]
}, Open  ]],
Cell[CellGroupData[{
Cell[91047, 2133, 224, 5, 70, "ExampleDelimiter",ExpressionUUID->"8a9cde25-f2db-4f79-b3d9-71bfd148b804"],
Cell[91274, 2140, 213, 3, 70, "ExampleText",ExpressionUUID->"bed11686-8480-49a4-8daa-1e633f936823"],
Cell[CellGroupData[{
Cell[91512, 2147, 859, 22, 70, "Input",ExpressionUUID->"b9a62700-fe9a-423b-bba2-041e25cb42aa"],
Cell[92374, 2171, 140, 2, 70, "Output",ExpressionUUID->"476036a1-2f4b-4f68-8bab-6662bc9b4148"]
}, Open  ]]
}, Open  ]]
}, Closed]]
}, Open  ]],
Cell[92565, 2179, 3112, 81, 70, "SeeAlsoSection",ExpressionUUID->"15d2a3d3-7c2b-4df6-a5cc-282a6165fb79"],
Cell[95680, 2262, 754, 19, 70, "MoreAboutSection",ExpressionUUID->"21c924d8-4b6a-46f3-ac19-b0c75fe9de77"],
Cell[96437, 2283, 78, 0, 70, "FooterCell",ExpressionUUID->"ea013728-40b2-4f19-b3df-05288fc4f933"]
}
]
*)

(* End of internal cache information *)

