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

(*** Wolfram CDF File ***)
(* http://www.wolfram.com/cdf *)

(* CreatedBy='Mathematica 12.1' *)

(***************************************************************************)
(*                                                                         *)
(*                                                                         *)
(*  Under the Wolfram FreeCDF terms of use, this file and its content are  *)
(*  bound by the Creative Commons BY-SA Attribution-ShareAlike license.    *)
(*                                                                         *)
(*        For additional information concerning CDF licensing, see:        *)
(*                                                                         *)
(*         www.wolfram.com/cdf/adopting-cdf/licensing-options.html         *)
(*                                                                         *)
(*                                                                         *)
(***************************************************************************)

(*CacheID: 234*)
(* Internal cache information:
NotebookFileLineBreakTest
NotebookFileLineBreakTest
NotebookDataPosition[      1088,         20]
NotebookDataLength[    259718,       5443]
NotebookOptionsPosition[    260043,       5434]
NotebookOutlinePosition[    260681,       5458]
CellTagsIndexPosition[    260638,       5455]
WindowTitle->matematykawszkole.com.pl
WindowFrame->Normal*)

(* Beginning of Notebook Content *)
Notebook[{
Cell[BoxData[
 TagBox[
  DynamicModuleBox[{}, 
   DynamicBox[ToBoxes[
     Refresh[
      Composition[
      Overlay[{#}, {1}, 1, ImageMargins -> 0, FrameMargins -> 0]& , 
       Framed[#, Alignment -> Center, FrameStyle -> None, FrameMargins -> 
        0]& , Column[#, Spacings -> 0.2]& ][{
        (Grid[{#}, Spacings -> {0, 0}]& )[{
          Framed[
           Dynamic[
            If[
             And[
             G10400601`warstwa != "Nic", G10400601`warstwa != "BrakDostepu", 
              G10400601`warstwa != "Przerwa", G10400601`warstwa != "ZaDuzo", 
              G10400601`warstwa != "Koniec"], G10400601`Logo, ""]], 
           FrameStyle -> None, ImageSize -> {100, 100}, Background -> 
           If[False, Red, $CellContext`KolorPodstawowyJasny], Alignment -> 
           Center], 
          Framed[
          "", ImageSize -> {3, 100}, Background -> White, FrameStyle -> None, 
           FrameMargins -> 0], 
          Overlay[{
            (((Dynamic[
            If[G10400601`powiekszenieMem != G10400601`aktualnePowiekszenie, 
               G10400601`powiekszenieMem = G10400601`aktualnePowiekszenie; 
               SetOptions[
                 EvaluationNotebook[], 
                 WindowSize -> ({700, 500} + {6, 145}) 
                  G10400601`powiekszenieMem]]; #]& )[
             
             Framed[#, FrameStyle -> None, 
              ImageSize -> {Part[{700, 500}, 1] - 206, 100}, 
              Background -> $CellContext`KolorPodstawowyJasny, Alignment -> 
              Center]]& )[
             Column[#, Alignment -> Center, Spacings -> 0.3]]& )[
             DeleteCases[{
               Style[
               "Oprocentowanie oszcz\:0119dno\:015bci i kredyt\[OAcute]w.", 
                $CellContext`paletaKolorow[0], FontFamily -> "Arial", 
                FontSize -> 18, TextAlignment -> Center], 
               If[False, 
                (Framed[#, FrameStyle -> White, Background -> Red]& )[
                 Style[
                 "Uwaga!!! \[CapitalCAcute]wiczenie w fazie test\[OAcute]w. \
Mog\:0105 wyst\:0105pi\[CAcute] b\[LSlash]\:0119dy.", White, FontFamily -> 
                  "Arial", FontSize -> 14, TextAlignment -> Center, Bold]], 
                ""], 
               Style["G1-040-06-01", 
                $CellContext`paletaKolorow[0], FontFamily -> "Arial", 
                FontSize -> 12]}, ""]], 
            ((
            Framed[#, FrameStyle -> None, 
             ImageSize -> {Part[{700, 500}, 1] - 206, 100}, 
             Alignment -> {Right, Bottom}]& )[
             Dynamic[
              If[
               And[
               G10400601`wariantUru == 1, G10400601`odlT > 
                G10400601`oCzasu - 15], #, ""]]]& )[
             Style[
              Dynamic[
               ToString[G10400601`oCzasu - G10400601`odlT]], 
              $CellContext`paletaKolorow[0.3], 30]]}, {1, 2}, 1], 
          Framed[
          "", ImageSize -> {3, 100}, Background -> White, FrameStyle -> None, 
           FrameMargins -> 0], 
          (
          Framed[#, FrameStyle -> None, ImageSize -> {100, 100}, 
           Background -> $CellContext`KolorPodstawowyJasny, Alignment -> 
           Center]& )[
           Dynamic[
            (Column[#, Spacings -> 0.15]& )[
             
             Part[{G10400601`OpisB, G10400601`TeoriaB, G10400601`KalkB, 
               G10400601`HistB}, {
               If[
                And[
                G10400601`warstwa != "Nic", G10400601`warstwa != 
                 "BrakDostepu", G10400601`warstwa != "Przerwa", 
                 G10400601`warstwa != "ZaDuzo", G10400601`warstwa != 
                 "Koniec"], 1, 
                Unevaluated[
                 Sequence[]]], 
               If[
                And[
                G10400601`warstwa != "Nic", G10400601`warstwa != 
                 "BrakDostepu", G10400601`warstwa != "Przerwa", 
                 G10400601`warstwa != "ZaDuzo", G10400601`warstwa != "Koniec", 
                 
                 OptionValue[{
                  G10400601`Tytu\[LSlash]C -> "tytulCwiczenia", 
                   G10400601`SymbolC -> "symbolCwiczenia", G10400601`Paleta -> 
                   "AlpineColors", ImageSize -> {700, 500}, 
                   G10400601`OpisSize -> {420., 300.}, 
                   G10400601`TeoriaSize -> {420., 300.}, 
                   G10400601`HistoriaSize -> {420., 300.}, G10400601`HistEn -> 
                   True, G10400601`HistoriaOn -> True, G10400601`TeoriaOn -> 
                   True}, {G10400601`Paleta -> {
                    RGBColor[0.0062, 0.0062, 0.0062], 
                    RGBColor[1., 0.4949, 0.0769], 
                    RGBColor[1., 0.939, 0.5384]}, G10400601`Tytu\[LSlash]C -> 
                   "Oprocentowanie oszcz\:0119dno\:015bci i \
kredyt\[OAcute]w.", G10400601`SymbolC -> "G1-040-06-01", 
                   ImageSize -> {700, 500}, G10400601`HistoriaOn -> False, 
                   G10400601`TeoriaOn -> False}, G10400601`TeoriaOn]], 2, 
                Unevaluated[
                 Sequence[]]], 
               If[
                And[
                G10400601`warstwa != "Nic", G10400601`warstwa != 
                 "BrakDostepu", G10400601`warstwa != "Przerwa", 
                 G10400601`warstwa != "ZaDuzo", G10400601`warstwa != 
                 "Koniec"], 3, 
                Unevaluated[
                 Sequence[]]], 
               If[
                And[
                G10400601`warstwa != "Nic", G10400601`warstwa != 
                 "BrakDostepu", G10400601`warstwa != "Przerwa", 
                 G10400601`warstwa != "ZaDuzo", G10400601`warstwa != "Koniec", 
                 
                 OptionValue[{
                  G10400601`Tytu\[LSlash]C -> "tytulCwiczenia", 
                   G10400601`SymbolC -> "symbolCwiczenia", G10400601`Paleta -> 
                   "AlpineColors", ImageSize -> {700, 500}, 
                   G10400601`OpisSize -> {420., 300.}, 
                   G10400601`TeoriaSize -> {420., 300.}, 
                   G10400601`HistoriaSize -> {420., 300.}, G10400601`HistEn -> 
                   True, G10400601`HistoriaOn -> True, G10400601`TeoriaOn -> 
                   True}, {G10400601`Paleta -> {
                    RGBColor[0.0062, 0.0062, 0.0062], 
                    RGBColor[1., 0.4949, 0.0769], 
                    RGBColor[1., 0.939, 0.5384]}, G10400601`Tytu\[LSlash]C -> 
                   "Oprocentowanie oszcz\:0119dno\:015bci i \
kredyt\[OAcute]w.", G10400601`SymbolC -> "G1-040-06-01", 
                   ImageSize -> {700, 500}, G10400601`HistoriaOn -> False, 
                   G10400601`TeoriaOn -> False}, G10400601`HistoriaOn]], 4, 
                Unevaluated[
                 Sequence[]]]}]]]]}], 
        Overlay[{
          Panel[
           Manipulate[
            Column[{
              Panel[
               Text[G10400601`zapis], 
               Background -> $CellContext`paletaKolorow[1], ImageMargins -> 0,
                FrameMargins -> 2, ImageSize -> {700 - 15, 30}, Alignment -> 
               Center], 
              Panel[
               (
               Pane[#, Scrollbars -> {False, True}, ImageSize -> {670, 250}, 
                AppearanceElements -> None]& )[
                
                Column[{
                 G10400601`kapital, G10400601`kredyt, G10400601`odsetki, 
                  G10400601`czasoprocentowania, G10400601`procent, 
                  G10400601`kapitalizacja, G10400601`procentProsty}, 
                 Alignment -> Left, Spacings -> 1]], 
               Background -> $CellContext`paletaKolorow[0.9], ImageMargins -> 
               0, FrameMargins -> 2, ImageSize -> {700 - 15, 270}, Alignment -> 
               Center], 
              (Grid[{#}, Spacings -> {0.4, 0}]& )[{
                Panel[
                 Text[G10400601`opisWzoru], 
                 Background -> $CellContext`paletaKolorow[0.9], ImageMargins -> 
                 0, FrameMargins -> 5, ImageSize -> {240, 100}, Alignment -> 
                 Center], 
                Panel[
                 Text[G10400601`wzor], 
                 Background -> $CellContext`paletaKolorow[0.9], ImageMargins -> 
                 0, FrameMargins -> 2, ImageSize -> {100, 100}, Alignment -> 
                 Center], 
                Dynamic[
                 Panel[
                  (Style[#, 14, FontFamily -> "Arial"]& )[
                   Column[{"Obliczamy odsetki:", 
                    TraditionalForm[
                    StringForm[
                    "\!\(\*FractionBox[\(`1`\\ \[CenterDot]\\ `2`\\ \
\[CenterDot]\\ `3`\), \(100\)]\) = `4``5`", G10400601`k, G10400601`p, 
                    G10400601`n, (G10400601`k G10400601`p G10400601`n)/100, 
                    If[
                    FractionalPart[(G10400601`k G10400601`p G10400601`n)/100] != 
                    0, 
                    Row[{" = ", 
                    NumberForm[
                    N[(G10400601`k G10400601`p G10400601`n)/100], {16, 2}, 
                    NumberPoint -> ","]}], ""]]]}, Alignment -> Left, 
                    Spacings -> 1]], 
                  Background -> $CellContext`paletaKolorow[0.9], ImageMargins -> 
                  0, FrameMargins -> 15, ImageSize -> {337, 100}, 
                  Alignment -> {Left, Center}]]}], 
              Grid[{{
                 G10400601`GSuwak[
                 G10400601`k, "Kapita\[LSlash] ", 
                  G10400601`Zakres -> {1000, 200000, 1000}], 
                 G10400601`GSuwak[
                 G10400601`p, "Procent ", G10400601`Zakres -> {1, 25, 1}], 
                 G10400601`GSuwak[
                 G10400601`n, "Czas oprocentowania (lata)", 
                  G10400601`Zakres -> {1, 24, 1}]}}, Spacings -> 0.2]}], 
            AppearanceElements -> None, ControlPlacement -> Bottom, Alignment -> 
            Center, Paneled -> False, SaveDefinitions -> True, 
            Initialization :> (G10400601`k = 1000; G10400601`p = 1; 
             G10400601`n = 1; 
             G10400601`st1 = Style[#, {12, FontFamily -> "Arial"}]& ; 
             G10400601`zapis = 
              Style["Podstawowe poj\:0119cia dotycz\:0105ce operacji \
finansowych dokonywanych w bankach.", Bold, 15, FontFamily -> "Arial"]; 
             G10400601`kapital = Column[{
                 Style[
                 " KAPITA\[CapitalLSlash]", Bold, FontFamily -> "Arial"], 
                 Style[
                 " - kwota, kt\[OAcute]r\:0105 wp\[LSlash]acamy do banku na \
okre\:015blony procent i czas.", FontFamily -> "Arial"]}]; 
             G10400601`kredyt = Column[{
                 Style[" KREDYT", Bold, FontFamily -> "Arial"], 
                 Style[
                 " - kwota, kt\[OAcute]r\:0105 po\:017cyczamy z banku na okre\
\:015blony procent i czas.", FontFamily -> "Arial"]}]; 
             G10400601`odsetki = Column[{
                 Style[
                 " ODSETKI (DOCH\[CapitalOAcute]D)", Bold, FontFamily -> 
                  "Arial"], 
                 Style[
                 " - kwota, kt\[OAcute]r\:0105 zyskujemy od powierzonego \
kapita\[LSlash]u lub kwota, ktor\:0105 dodatkowo wp\[LSlash]acamy do banku \
przy sp\[LSlash]acie", FontFamily -> "Arial"], 
                 Style["kredytu.", FontFamily -> "Arial"]}]; 
             G10400601`czasoprocentowania = Column[{
                 Style[" CZAS OPROCENTOWANIA", Bold, FontFamily -> "Arial"], 
                 Style[
                 " - okres, na kt\[OAcute]ry zosta\[LSlash]a zawarta umowa z \
bankiem.", FontFamily -> "Arial"]}]; G10400601`procent = Column[{
                 Style[
                 " PROCENT (STOPA PROCENTOWA)", Bold, FontFamily -> "Arial"], 
                 
                 Style[
                 " - stosunek odsetek do kapita\[LSlash]u, wyra\:017cony w \
procentach (najcz\:0119\:015bciej si\:0119 go podaje w stosunku rocznym).", 
                  FontFamily -> "Arial"]}]; 
             G10400601`kapitalizacja = Column[{
                 Style[" KAPITALIZACJA ODSETEK", Bold, FontFamily -> "Arial"], 
                 Style[
                 " - dodanie (dopisanie) odsetek do kapita\[LSlash]u. Odsetki \
zaczynaj\:0105 wtedy kapitalizowa\[CAcute] wraz z kapita\[LSlash]em. Czas po \
jakim \nnast\:0119puje kapitalizacja odsetek zale\:017cy od rodzaju lokaty. \
Mo\:017ce to by\[CAcute] np. rok, 3 miesi\:0105ce, czy te\:017c 6 \
miesi\:0119cy.", FontFamily -> "Arial", LineIndent -> 0]}]; 
             G10400601`procentProsty = Column[{
                 Style[" PROCENT PROSTY", Bold, FontFamily -> "Arial"], 
                 Style[
                 " - spos\[OAcute]b oprocentowania wk\[LSlash]adu pieni\:0119\
\:017cnego, polegaj\:0105cy na tym, \:017ce odsetki od wk\[LSlash]adu pocz\
\:0105tkowego s\:0105 wyznaczane proporcjonalnie do d\[LSlash]ugo\:015bci \
okresu oprocentowania i nie s\:0105 doliczane do wk\[LSlash]adu, czyli nie \
podlegaj\:0105 kapitalizacji, co oznacza, \:017ce nie procentuj\:0105 w nast\
\:0119pnym okresie rozliczeniowym wraz z kapita\[LSlash]em. Pokazany poni\
\:017cej przyk\[LSlash]ad liczbowy jest przyk\[LSlash]adem oprocentowania wk\
\[LSlash]adu procentem prostym.", FontFamily -> "Arial", LineIndent -> 0]}]; 
             G10400601`opisWzoru = Column[{
                 Style["kapita\[LSlash] (kredyt) - k", FontFamily -> "Arial"], 
                 Style["odsetki (doch\[OAcute]d) - d", FontFamily -> "Arial"], 
                 Style[
                 "procent (stopa oprocentowania) - p", FontFamily -> "Arial"], 
                 Style[
                 "czas oprocentowania (w latach) - t", FontFamily -> 
                  "Arial"]}]; G10400601`wzor := Row[{
                 Style["  d=", FontFamily -> "Arial", 15], 
                 Style[
                  StringJoin[
                   ToString[
                    TraditionalForm[
                    Style["k\[CenterDot]p\[CenterDot]t", Italic, 15]/Style[
                    "100", 15]]], "  "], 15, FontFamily -> "Arial"]}]; 
             SetAttributes[G10400601`GSuwak, HoldFirst]; 
             Options[G10400601`GSuwak] = {
               Background -> $CellContext`paletaKolorow[0.8], 
                G10400601`Zakres -> {-9, 9, 1/2}, Exclusions -> None}; 
             G10400601`GSuwak[
                Pattern[G10400601`q, 
                 Blank[]], 
                Pattern[G10400601`opis, 
                 Blank[]], 
                OptionsPattern[]] := Framed[
                Column[{
                  Row[{
                    G10400601`st1[
                    StringJoin[G10400601`opis, " = "]], 
                    G10400601`st1[
                    Framed[
                    Dynamic[
                    Rationalize[G10400601`q]], FrameStyle -> None, 
                    ImageSize -> {Automatic, 30}, ImageMargins -> 0, 
                    FrameMargins -> 0]]}], 
                  Slider[
                   Dynamic[G10400601`q], 
                   OptionValue[G10400601`Zakres], Exclusions -> 
                   OptionValue[Exclusions], ImageSize -> 200]}, Alignment -> 
                 Left], Alignment -> Center, ImageSize -> {227, 70}, 
                FrameMargins -> 0, ImageMargins -> 0, FrameStyle -> None, 
                Background -> OptionValue[Background]]; Null)], 
           ImageSize -> {700, 500}, FrameMargins -> 0, ImageMargins -> 0, 
           Background -> $CellContext`paletaKolorow[0.1], Alignment -> 
           Center], 
          Dynamic[
           Refresh[
            G10400601`RuchomyModul[{700, 500}, G10400601`KALKULATOR], None]], 
          
          Dynamic[
           G10400601`pokazOpis[
            Join[G10400601`tekstOpisu, {{0, 
               Style[
                If[G10400601`czyJestPolaczenie, 
                 Dynamic[
                  StringJoin[
                  "----------\n", 
                   "Po\[LSlash]\:0105czenie z baz\:0105\nTWLB: ", 
                   DateString[G10400601`dataWL, "ISODate"], 
                   "\nTyp dost\:0119pu (1, 2, 3): ", 
                   ToString[G10400601`typDostepu], "\n", 
                   "Wariant uruchomienia (T, B, BH): ", 
                   ToString[G10400601`wariantUru], "\n", 
                   "Zalogowany u\:017cytkownik: ", G10400601`uzytkownik]], 
                 "Brak po\[LSlash]\:0105czenia"], 10]}}], {700, 500}, {420., 
            300.}]], 
          G10400601`pokazOpis[
          G10400601`tekstTeorii, {700, 500}, {420., 300.}], 
          G10400601`pokazOpisH[
          G10400601`tekstHistorii, {700, 500}, {420., 300.}, Center], 
          Dynamic[
           Refresh[
            G10400601`RuchomyModul[{700, 500}, 
             Dynamic[G10400601`WPROWADZ]], None]], 
          Dynamic[
           Refresh[
            G10400601`RuchomyModul[{700, 500}, G10400601`poleKomunikatu], 
            TrackedSymbols :> {G10400601`poleKomunikatu}]], 
          G10400601`pokazK[{700, 500}], 
          G10400601`pokazZaDuzoCDF[{700, 500}], 
          G10400601`pokazKoniec[{700, 500}], 
          Dynamic[
           G10400601`pokazBrakDostepu[{700, 500}]], 
          G10400601`pokazPrzerwa[{700, 500}]}, 
         Dynamic[
          Switch[
          G10400601`warstwa, "Program", {1}, "Kalkulator", {1, 2}, "Opis", {1,
            3}, "Teoria", {1, 4}, "Historia", {1, 5}, "Wprowad\:017a", {1, 6},
            "Komunikat", {1, 7}, "Nic", {1, 8}, "ZaDuzo", {1, 9}, "Koniec", {
           1, 10}, "BrakDostepu", {1, 11}, "Przerwa", {1, 12}], 
          TrackedSymbols :> {G10400601`warstwa}], 
         Dynamic[
          Switch[
          G10400601`warstwa, "Program", 1, "Kalkulator", 2, "Opis", 3, 
           "Teoria", 4, "Historia", 5, "Wprowad\:017a", 6, "Komunikat", 7, 
           "Nic", 8, "ZaDuzo", 9, "Koniec", 10, "BrakDostepu", 11, "Przerwa", 
           12], TrackedSymbols :> {G10400601`warstwa}], ImageMargins -> 0, 
         FrameMargins -> 0], 
        (Grid[{#}, Spacings -> 0, 
         BaseStyle -> {
          FontFamily -> "Arial", 12, $CellContext`KolorPodstawowy}]& )[{
          (Framed[
           Row[{#, 
             Dynamic[
              G10400601`kropki[]]}], 
           ImageSize -> {0.7 Part[{700, 500}, 1], Automatic}, FrameMargins -> 
           0, Alignment -> Left, FrameStyle -> None]& )[
           Hyperlink[
            Gambit`GLC[
            "\[DoubleDot]\.1f1/02,1/10+\.1fF`lahs+\.1fvvv-f`lahs-mds-ok"], 
            Gambit`GLC[
            "gsso9..vvv-f`lahs-mds-ok.ok`shmtl.f`lahsbnoxqhfgs-gslk"], 
            ActiveStyle -> 
            Directive[$CellContext`KolorPodstawowy, Underlined]]], 
          (
          Framed[#, ImageSize -> {0.3 Part[{700, 500}, 1], Automatic}, 
           ImageMargins -> 0, FrameMargins -> 0, Alignment -> Right, 
           FrameStyle -> None]& )[
           Hyperlink[
            Gambit`GLC["vvv-l`sgdl`shb`-ok"], 
            Gambit`GLC["gsso9..vvv-l`sgdl`shb`-ok"], ActiveStyle -> 
            Directive[$CellContext`KolorPodstawowy, Underlined]]]}]}], None], 
     StandardForm],
    ImageSizeCache->{702., {309., 315.}}],
   DynamicModuleValues:>{},
   Initialization:>({
     G10400601`warstwa = "Nic", G10400601`Logo := 
      With[{G10400601`opacity = 0.9, 
         G10400601`kolor = $CellContext`paletaKolorow[0.9]}, 
        DynamicModule[{}, 
         Deploy[
          Graphics3D[{
            EdgeForm[{Thick, G10400601`kolor}], 
            GraphicsComplex[G10400601`pts, {G10400601`kolor, 
              Opacity[G10400601`opacity], 
              FaceForm[
               Texture[G10400601`tex]], 
              Polygon[
              G10400601`vv, VertexTextureCoordinates -> 
               Table[G10400601`vtc, {6}]]}]}, Lighting -> "Neutral", Boxed -> 
           False, ImageSize -> {90, 90}, 
           Method -> {"RotationControl" -> "Globe"}, RotationAction -> "Clip",
            ViewPoint -> Dynamic[
             
             With[{G10400601`p = 
               2 MousePosition[{"Graphics", DynamicModule}, {2, 0}]}, 
              G10400601`pPP = G10400601`p; 22 {(-Cos[
                    Part[G10400601`p, 1]]) Sin[
                   Part[G10400601`p, 2]], Sin[
                   Part[G10400601`p, 1]] Sin[
                   Part[G10400601`p, 2]], 
                 Cos[
                  Part[G10400601`p, 2]]}]]]], SaveDefinitions -> True, 
         Initialization -> (G10400601`pts = G10400601`pts0; 
          G10400601`vv = G10400601`vv0; G10400601`vtc = G10400601`vtc0; 
          G10400601`tex = G10400601`tex0; Null)]], $CellContext`paletaKolorow = 
      Blend[{
         RGBColor[0.0062, 0.0062, 0.0062], 
         RGBColor[1., 0.4949, 0.0769], 
         RGBColor[1., 0.939, 0.5384]}, #]& , 
      G10400601`pts0 = {{-1, -1, -1}, {1, -1, -1}, {1, 1, -1}, {-1, 
       1, -1}, {-1, -1, 1}, {1, -1, 1}, {1, 1, 1}, {-1, 1, 1}}, 
      G10400601`vv0 = {{1, 2, 3, 4}, {5, 6, 7, 8}, {1, 2, 6, 5}, {2, 3, 7, 
       6}, {3, 4, 8, 7}, {4, 1, 5, 8}}, 
      G10400601`vtc0 = {{0.01, 0.01}, {0.99, 0.01}, {0.99, 0.99}, {0.01, 
       0.99}}, G10400601`tex0 = Graphics[{
         Inset[
          Image[CompressedData["
1:eJzNnPlbE9cax1MWkbXsuLRaLTthCwmL1kqr4Ira2tbrUlGs2tqKsiRkJyEQ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           "], "Byte", ColorSpace -> 
           "RGB", ImageSize -> 90, Interleaving -> True, Magnification -> 
           Automatic], {0.53, 0.5}]}, PlotRange -> {{0, 1}, {0, 1}}, 
        ImageSize -> {90, 90}, Background -> 
        RGBColor[
         1., 0.8501799999999999, 
          0.44610000000000005`]], $CellContext`KolorPodstawowyJasny = 
      RGBColor[1., 0.76136, 0.3538], G10400601`powiekszenieMem = 1., 
      G10400601`aktualnePowiekszenie := (If[
        MatchQ[
         Head[#], Times], 
        Part[#, 1], #]& )[
        CurrentValue[
         EvaluationNotebook[], Magnification]], G10400601`wariantUru = 1, 
      G10400601`odlT = 0, G10400601`oCzasu = 180, G10400601`OpisB := 
      G10400601`GButton[
        Style[
        "Opis", 12, $CellContext`KolorPodstawowyJasny, Bold, FontFamily -> 
         "Arial"], 
        If[
         Or[
         G10400601`warstwa == "ZaDuzo", G10400601`warstwa == "Koniec", 
          G10400601`warstwa == "BrakDostepu", G10400601`warstwa == "Przerwa"], 
         NotebookClose[], G10400601`warstwa = "Opis"], ImageSize -> {90, 20}, 
        G10400601`BaseColor -> Darker[$CellContext`KolorPodstawowy], Enabled -> 
        G10400601`warstwa != "Nic"], 
      Attributes[G10400601`GButton] = {HoldRest}, G10400601`GButton[
        Pattern[G10400601`ob, 
         Blank[]], 
        Pattern[G10400601`proc, 
         Blank[]], 
        Optional[
         Pattern[G10400601`enabled, 
          Except[
           Blank[Rule]]], True], 
        OptionsPattern[]] := DynamicModule[{G10400601`col = If[
           OptionValue[Enabled], 
           OptionValue[G10400601`BaseColor], 
           OptionValue[G10400601`DissColor]]}, 
        MouseAppearance[
         Button[
          Framed[
           G10400601`GBStyle[12][G10400601`ob], ImageSize -> 
           OptionValue[ImageSize], FrameMargins -> 0, FrameStyle -> None, 
           Alignment -> OptionValue[Alignment], Background -> Dynamic[
             Which[
              And[
               CurrentValue["MouseOver"], CurrentValue["MouseButtons"] == {}], 
              Lighter[G10400601`col], 
              And[
               CurrentValue["MouseOver"], CurrentValue["MouseButtons"] != {}], 
              OptionValue[G10400601`PressedColor], True, G10400601`col], 
             TrackedSymbols :> {G10400601`enabled}], ImageMargins -> 0], 
          G10400601`proc, Enabled -> OptionValue[Enabled], 
          Appearance -> {None, "Pressed"}, Background -> Black, ImageSize -> 
          OptionValue[ImageSize]], "LinkHand"]], 
      Options[G10400601`GButton] = {
       ImageSize -> {45, 45}, Alignment -> Center, Enabled -> True, 
        G10400601`BaseColor -> RGBColor[0.8012400000000001, 0.39716, 0.06276],
         Background -> None, G10400601`PressedColor -> 
        RGBColor[1., 0.8501799999999999, 0.44610000000000005`], Appearance -> 
        None, G10400601`DissColor -> 
        RGBColor[1., 0.8057699999999999, 0.39995]}, G10400601`GBStyle[
        Pattern[G10400601`size, 
         BlankSequence[]]] := Style[#, 
        $CellContext`paletaKolorow[1], G10400601`size, Bold, FontFamily -> 
        "Arial"]& , $CellContext`KolorPodstawowy = 
      RGBColor[0.40372, 0.20168000000000003`, 0.03448], G10400601`TeoriaB := 
      G10400601`GButton[
        Style[
        "Teoria", 12, $CellContext`KolorPodstawowyJasny, Bold, FontFamily -> 
         "Arial"], 
        If[
         Or[
         G10400601`warstwa == "ZaDuzo", G10400601`warstwa == "Koniec", 
          G10400601`warstwa == "BrakDostepu", G10400601`warstwa == "Przerwa"], 
         NotebookClose[], G10400601`warstwa = "Teoria"], 
        ImageSize -> {90, 20}, G10400601`BaseColor -> 
        Darker[$CellContext`KolorPodstawowy], Enabled -> 
        G10400601`warstwa != "Nic"], G10400601`KalkB := G10400601`GButton[
        Style[
        "Kalkulator", 12, $CellContext`KolorPodstawowyJasny, Bold, FontFamily -> 
         "Arial"], G10400601`KALKULATOR = G10400601`Kalkulator; If[
          Or[
          G10400601`warstwa == "ZaDuzo", G10400601`warstwa == "Koniec", 
           G10400601`warstwa == "BrakDostepu", G10400601`warstwa == 
           "Przerwa"], 
          NotebookClose[], G10400601`warstwa = "Kalkulator"; Null], 
        ImageSize -> {90, 20}, G10400601`BaseColor -> 
        Darker[$CellContext`KolorPodstawowy], Enabled -> 
        G10400601`warstwa != "Nic"], G10400601`Kalkulator := 
      With[{G10400601`t\[LSlash]oW = $CellContext`paletaKolorow[0.99], 
         G10400601`t\[LSlash]oK = $CellContext`paletaKolorow[0.6]}, 
        Module[{G10400601`liczba, G10400601`gdzie, G10400601`war = "0"}, 
         DynamicModule[{
          G10400601`wynik = False, G10400601`PrzyciskB, G10400601`PrzecinekB, 
           G10400601`UsunB, G10400601`ResetB, G10400601`DzialanieB, 
           G10400601`wynikB, G10400601`WynikB, G10400601`PlusB}, 
          G10400601`gdzie := If[StringCount[
               StringTake[G10400601`war, {2, -1}], {"(", ")"}] == 0, -1, -2]; 
          G10400601`liczba := Part[
             StringCases[G10400601`war, StringExpression[
                Pattern[G10400601`z1, 
                 RepeatedNull["-"]], 
                Pattern[G10400601`x1, 
                 Repeated[DigitCharacter]], 
                Pattern[G10400601`k1, 
                 RepeatedNull[","]], 
                Pattern[G10400601`x2, 
                 RepeatedNull[DigitCharacter]], 
                RepeatedNull[
                 Pattern[G10400601`d, 
                  Blank[]]], 
                RepeatedNull["("], 
                Pattern[G10400601`z2, 
                 RepeatedNull["-"]], 
                Pattern[G10400601`y1, 
                 RepeatedNull[DigitCharacter]], 
                Pattern[G10400601`k2, 
                 RepeatedNull[","]], 
                Pattern[G10400601`y2, 
                 RepeatedNull[DigitCharacter]], 
                RepeatedNull[")"]] :> {
               G10400601`z1, G10400601`x1, G10400601`k1, G10400601`x2, 
                G10400601`d, G10400601`z2, G10400601`y1, G10400601`k2, 
                G10400601`y2}], 1]; G10400601`PrzyciskB := G10400601`GButton[
             G10400601`GBStyle[20][#], 
             If[G10400601`wynik, G10400601`war = "0"; G10400601`wynik = False; 
               Null]; Which[
               Or[G10400601`war == "0", G10400601`war == "-"], 
               G10400601`war = #, 
               And[G10400601`SL[G10400601`war] < 14, 
                If[G10400601`SL[G10400601`war] > 0, G10400601`SL[
                   Part[
                    StringSplit[G10400601`war, {"+", "-", "\[Cross]", "/"}], 
                    1]] < 15, True]], G10400601`war = 
               G10400601`SIn[G10400601`war, #, G10400601`gdzie]], 
             G10400601`BaseColor -> $CellContext`KolorPodstawowyJasny]& ; 
          G10400601`UsunB = G10400601`GButton[
             G10400601`GBStyle[20]["\[LeftArrow]"], 
             Which[G10400601`SL[G10400601`war] == 1, G10400601`war = "0", 
               And[G10400601`SL[G10400601`war] >= 6, 
                StringMatchQ[
                 StringTake[G10400601`war, {-4, -1}], 
                 StringExpression["(-", 
                  Blank[], ")"]]], G10400601`war = 
               StringDrop[G10400601`war, -5], True, G10400601`war = 
               StringDrop[G10400601`war, {G10400601`gdzie}]]; 
             G10400601`wynik = False; Null]; 
          G10400601`PrzecinekB = G10400601`GButton[
             G10400601`GBStyle[20][","], 
             If[G10400601`wynik, G10400601`war = "0"; G10400601`wynik = False; 
               Null]; Which[
              Part[G10400601`liczba, -2] == ",", Null, 
               Part[G10400601`liczba, -3] != "", G10400601`war = 
               G10400601`SIn[G10400601`war, ",", G10400601`gdzie], 
               And[
               Part[G10400601`liczba, -5] == "", Part[G10400601`liczba, 3] == 
                ""], G10400601`war = 
               G10400601`SIn[G10400601`war, ",", G10400601`gdzie], 
               Or[
               G10400601`SL[G10400601`war] == 0, G10400601`war == "0", 
                G10400601`war == "-"], G10400601`war = "0,"]]; 
          G10400601`DzialanieB = G10400601`GButton[
             G10400601`GBStyle[20][#], 
             Which[G10400601`SL[G10400601`war] == 1, G10400601`war = 
               G10400601`SIn[G10400601`war, #, -1], 
               And[G10400601`SL[G10400601`war] < 14, StringCount[
                  StringTake[G10400601`war, {2, -1}], {
                  "+", "-", "\[Cross]", "/"}] == 0], 
               If[
               StringTake[G10400601`war, -1] == ",", G10400601`war = 
                StringReplacePart[G10400601`war, #, {-1, -1}], G10400601`war = 
                G10400601`SIn[G10400601`war, #, -1]]]; 
             G10400601`wynik = False; Null]& ; 
          G10400601`WynikB = G10400601`GButton[
             G10400601`GBStyle[20]["="], Which[
               MemberQ[{"+", "-", "\[Cross]", "/"}, 
                StringTake[G10400601`war, -1]], G10400601`war = 
               StringDrop[G10400601`war, -1], G10400601`format[G10400601`war] != 
               "ComplexInfinity", G10400601`war = 
               G10400601`format[G10400601`war]]; G10400601`wynik = True; Null,
              ImageSize -> {97, 45}]; G10400601`ResetB = G10400601`GButton[
             G10400601`GBStyle[20]["C"], G10400601`war = "0"]; 
          G10400601`PlusB = G10400601`GButton["+/-", 
             Which[
              Or[G10400601`SL[G10400601`war] >= 14, G10400601`war == "0", 
               Not[
                StringMatchQ[
                 StringTake[G10400601`war, -1], 
                 StringExpression[
                  RepeatedNull[DigitCharacter], 
                  RepeatedNull[")"]]]]], Null, StringCount[
                StringTake[G10400601`war, {2, -1}], {
                "+", "-", "\[Cross]", "/"}] == 0, 
              If[StringTake[G10400601`war, 1] == "-", G10400601`war = 
                StringDrop[G10400601`war, 1], G10400601`war = 
                G10400601`SIn[G10400601`war, "-", 1]]; Null, StringCount[
                StringTake[G10400601`war, {2, -1}], {"(", ")"}] != 0, 
              G10400601`war = (With[{G10400601`dzia\[LSlash]anie = Part[
                   StringCases[#, {"+", "-", "/", "\[Cross]"}], -2]}, 
                
                Module[{G10400601`liczby, G10400601`x, G10400601`y}, 
                 G10400601`liczby = Part[
                    StringCases[#, StringExpression[
                    Pattern[G10400601`x, 
                    BlankSequence[]], G10400601`dzia\[LSlash]anie, "(-", 
                    Pattern[G10400601`y, 
                    BlankSequence[]], ")"] -> {G10400601`x, G10400601`y}], 1]; 
                 StringJoin[
                   Part[G10400601`liczby, 1], G10400601`dzia\[LSlash]anie, 
                   Part[G10400601`liczby, 2]]]]& )[G10400601`war], True, 
              G10400601`war = (With[{G10400601`dzia\[LSlash]anie = Part[
                   StringCases[#, {"+", "-", "/", "\[Cross]"}], -1]}, 
                
                Module[{G10400601`liczby}, 
                 G10400601`liczby = 
                  StringSplit[#, G10400601`dzia\[LSlash]anie]; StringJoin[
                   Part[G10400601`liczby, -2], G10400601`dzia\[LSlash]anie, 
                   "(-", 
                   Part[G10400601`liczby, -1], ")"]]]& )[G10400601`war]]]; 
          Dynamic[
            Framed[
             Column[{
               Framed[
                G10400601`SW[
                 TraditionalForm[
                  Dynamic[G10400601`war]]], ImageSize -> {245, 50}, 
                ImageMargins -> 0, Background -> G10400601`t\[LSlash]oW, 
                FrameStyle -> None, Alignment -> Right], 
               (Grid[#, Spacings -> 0.5]& )[{{
                  G10400601`PrzyciskB["7"], 
                  G10400601`PrzyciskB["8"], 
                  G10400601`PrzyciskB["9"], G10400601`UsunB, 
                  G10400601`ResetB}, {
                  G10400601`PrzyciskB["4"], 
                  G10400601`PrzyciskB["5"], 
                  G10400601`PrzyciskB["6"], 
                  G10400601`DzialanieB["\[Cross]"], 
                  G10400601`DzialanieB["/"]}, {
                  G10400601`PrzyciskB["1"], 
                  G10400601`PrzyciskB["2"], 
                  G10400601`PrzyciskB["3"], 
                  G10400601`DzialanieB["+"], 
                  G10400601`DzialanieB["-"]}, {
                  G10400601`PrzyciskB["0"], G10400601`PrzecinekB, 
                  G10400601`PlusB, G10400601`WynikB, SpanFromLeft}}]}, 
              Alignment -> Center, Spacings -> 0.5], ImageSize -> {280, 290}, 
             Alignment -> Center, FrameStyle -> None, Background -> 
             G10400601`t\[LSlash]oK, ImageMargins -> 0]]]]], 
      G10400601`t\[LSlash]oW = RGBColor[1., 0.930118, 0.52917], 
      G10400601`t\[LSlash]oK = RGBColor[1., 0.4949, 0.0769], G10400601`SL = 
      StringLength, G10400601`SIn = StringInsert, G10400601`format := Quiet[
        (G10400601`SRep[#, "." -> ","]& )[
         StringTrim[
          (G10400601`SRep[#, StringExpression[
             RegularExpression["0{2,15}&"], 
             Blank[]] -> ""]& )[
           ToString[
            NumberForm[
             (If[
              And[
               ExactNumberQ[#], FractionalPart[#] != 0], 
              N[#], #]& )[
              ToExpression[
               G10400601`SRep[#, {"," -> ".", "\[Cross]" -> " "}]]], 9, 
             ExponentFunction -> (If[-20 < # < 20, Null, #]& )]]], 
          Repeated["."]]]]& , G10400601`SRep = StringReplace, G10400601`SW = 
      Style[#, 
        $CellContext`paletaKolorow[0], 
        Opacity[0.7], Bold, 28, FontFamily -> "Arial"]& , G10400601`HistB := 
      G10400601`GButton[
        Style[
        "Historia", 12, $CellContext`KolorPodstawowyJasny, Bold, FontFamily -> 
         "Arial"], 
        If[
         Or[
         G10400601`warstwa == "ZaDuzo", G10400601`warstwa == "Koniec", 
          G10400601`warstwa == "BrakDostepu", G10400601`warstwa == "Przerwa"], 
         NotebookClose[], G10400601`warstwa = "Historia"], 
        ImageSize -> {90, 20}, Enabled -> And[
          
          OptionValue[{
           G10400601`Tytu\[LSlash]C -> "tytulCwiczenia", G10400601`SymbolC -> 
            "symbolCwiczenia", G10400601`Paleta -> "AlpineColors", 
            ImageSize -> {700, 500}, G10400601`OpisSize -> {420., 300.}, 
            G10400601`TeoriaSize -> {420., 300.}, 
            G10400601`HistoriaSize -> {420., 300.}, G10400601`HistEn -> True, 
            G10400601`HistoriaOn -> True, G10400601`TeoriaOn -> True}, {
           G10400601`Paleta -> {
              RGBColor[0.0062, 0.0062, 0.0062], 
              RGBColor[1., 0.4949, 0.0769], 
              RGBColor[1., 0.939, 0.5384]}, G10400601`Tytu\[LSlash]C -> 
            "Oprocentowanie oszcz\:0119dno\:015bci i kredyt\[OAcute]w.", 
            G10400601`SymbolC -> "G1-040-06-01", ImageSize -> {700, 500}, 
            G10400601`HistoriaOn -> False, G10400601`TeoriaOn -> False}, 
           G10400601`HistEn], G10400601`warstwa != "Nic"], 
        G10400601`BaseColor -> Darker[$CellContext`KolorPodstawowy]], 
      G10400601`RuchomyModul[
        Pattern[$CellContext`wymiary, 
         Blank[]], 
        Pattern[G10400601`co, 
         Blank[]]] := 
      With[{G10400601`RamRM = 
         Sequence[
          FrameMargins -> 0, Alignment -> {Center, Bottom}, ImageMargins -> 
           0], G10400601`size = ImageDimensions[
           Rasterize[G10400601`co]], G10400601`wid = 26}, 
        DynamicModule[{
         G10400601`n = {
           Part[G10400601`size, 1]/Part[$CellContext`wymiary, 1], 
            Part[G10400601`size, 2]/Part[$CellContext`wymiary, 2]}, 
          G10400601`opacity = 0.6, G10400601`Przesun = Graphics[{
             Arrowheads[{-0.35, 0.35}], 
             Arrow[{{-1, 0}, {1, 0}}], 
             Arrow[{{0, -1}, {0, 1}}]}, PlotRange -> 1, ImageSize -> {20, 20},
             ImageMargins -> 0, ImagePadding -> 0, PlotRangePadding -> 0], 
          G10400601`LewyPasek}, 
         Graphics[{{White, 
            Opacity[
             Dynamic[G10400601`opacity]], 
            Rectangle[{-1, -1}, {1, 1}]}, 
           Inset[
            Row[{G10400601`co, 
              Framed[
               Dynamic[
                Refresh[G10400601`LewyPasek, None]], ImageSize -> {26, 
                 Part[G10400601`size, 2]}, Alignment -> {Center, Bottom}, 
               FrameMargins -> 0, FrameStyle -> None, 
               Background -> $CellContext`paletaKolorow[0.6]]}, "  ", 
             Alignment -> Top], 
            Dynamic[
             Offset[{13, 13}, G10400601`n]], {Right, Top}], 
           Locator[
            Dynamic[G10400601`n], G10400601`Przesun]}, PlotRange -> 1, 
          ImageSize -> $CellContext`wymiary, AspectRatio -> 
          Part[$CellContext`wymiary, 2]/Part[$CellContext`wymiary, 1], 
          ImageMargins -> 0, ImagePadding -> False, Frame -> False, Axes -> 
          False], Initialization :> (
          G10400601`LewyPasek := (Pane[#, {G10400601`wid, 
              Part[G10400601`size, 2]}, G10400601`RamRM]& )[
             Column[
              Apply[Pane[#, {G10400601`wid, #2}, G10400601`RamRM]& , {{
                 VerticalSlider[
                  Dynamic[G10400601`opacity], 
                  ImageSize -> {
                   Tiny, Part[G10400601`size, 2] - 2 G10400601`wid}, 
                  G10400601`RamRM], Automatic}, {
                 Dynamic[G10400601`WYLACZNIK], G10400601`wid}}, {1}], 
              Alignment -> Center, Spacings -> 0, 
              Background -> $CellContext`paletaKolorow[0.6]]]; 
          Null)]], $CellContext`wymiary = {700, 500}, G10400601`WYLACZNIK = 
      MouseAppearance[
        Button[
         Graphics[
          Dynamic[{Thick, 
            If[
             CurrentValue["MouseOver"], Red, 
             $CellContext`paletaKolorow[1]], 
            Circle[{0., 0.}, 1., {((-5.)/4) Pi, (1./4) Pi}], 
            Line[{{0., 0.}, {0., 1.2}}]}], 
          PlotRange -> {{-1.5, 1.5}, {-1.5, 1.5}}, ImageSize -> {20, 20}], 
         G10400601`warstwa = "Program", Appearance -> "Frameless"], 
        "LinkHand"], G10400601`pokazOpis[
        Pattern[G10400601`tekstOpisu, 
         Blank[]], 
        Pattern[$CellContext`wymiary, 
         Blank[]], 
        Pattern[G10400601`wymiarywew, 
         Blank[]], 
        Optional[
         Pattern[G10400601`align, 
          Blank[]], Left]] := 
      With[{G10400601`fM = FrameMargins, G10400601`iM = ImageMargins, 
         G10400601`AL = Alignment}, 
        DynamicModule[{
         G10400601`opis, G10400601`tytulOpisu = Part[G10400601`tekstOpisu, 2],
           G10400601`trescOpisu = Drop[G10400601`tekstOpisu, 2], 
          G10400601`ZAMKNIJ}, 
         Dynamic[G10400601`opis], 
         Initialization :> (G10400601`opis := Framed[
             (((((Panel[#, Background -> Directive[{
                 Opacity[0.8], $CellContext`KolorPodstawowy}], FrameMargins -> 
              3, ImageMargins -> 0, Alignment -> Center]& )[
              Column[{
                Pane[
                 G10400601`OPIS[G10400601`tytulOpisu], Alignment -> 
                 G10400601`align, FrameMargins -> 0, ImageMargins -> 0], #, 
                Item[
                 Dynamic[G10400601`WYLACZNIK], Alignment -> Right]}]]& )[
              
              Panel[#, Background -> $CellContext`paletaKolorow[1], 
               FrameMargins -> 0, ImageMargins -> 0, Alignment -> Center]]& )[
             
              
              Pane[#, G10400601`wymiarywew, ImageMargins -> 5, Alignment -> 
               Left, Scrollbars -> {False, True}, AppearanceElements -> 
               None]]& )[
              Column[#, Alignment -> Left, ItemSize -> Scaled[1]]]& )[
              Apply[Switch[#, 0, 
                G10400601`TEKST[#2], 1, 
                G10400601`NAGLOWEK[#2], 2, 
                G10400601`SEKCJA[#2], 3, 
                G10400601`WZORY[#2], 4, 
                Item[#2, Alignment -> Center]]& , G10400601`trescOpisu, {1}]],
              Background -> Directive[{
                Opacity[0.6], White}], ImageSize -> $CellContext`wymiary, 
             Alignment -> Center, FrameStyle -> None]; Null)]], 
      G10400601`tekstOpisu = {
       "", "Opis", {2, "Opis dzia\[LSlash]ania"}, {
        0, "W pokazie tym zosta\[LSlash]o przedstawione w jaki spos\[OAcute]b \
mo\:017cna obliczy\[CAcute]"}, {
        0, 
         "odsetki doliczane do oszcz\:0119dno\:015bci i do \
kredyt\[OAcute]w."}, {0, " "}, {
        0, "Ekran jest podzielony na cz\:0119\:015bci: teoretyczn\:0105, \
pokaz oraz panel"}, {0, "kontrolny, znajduj\:0105cy si\:0119 na dole."}, {
        0, " "}, {
        0, "U\:017cytkownik suwakami okre\:015bla warto\:015b\[CAcute] kapita\
\[LSlash]u, procent i okres"}, {
        0, "oprocentowania. Warto\:015bci te automatycznie zostaj\:0105 \
podstawione do"}, {0, "wzoru obliczaj\:0105c odsetki."}, {0, " "}, {
        2, "Elementy obs\[LSlash]ugi \[CAcute]wiczenia"}, {0, " "}, {2, 
         Row[{
           Style["Kapita\[LSlash] = ", 12, 
            GrayLevel[0.2], FontFamily -> "Arial", Plain], 
           Slider[0.5, ImageSize -> Small]}]}, {
        0, "Zmienia waro\:015b\[CAcute] liczby k - kapita\[LSlash]u."}, {
        0, " "}, {2, 
         Row[{
           Style["Procent = ", 12, 
            GrayLevel[0.2], FontFamily -> "Arial", Plain], 
           Slider[0.5, ImageSize -> Small]}]}, {
        0, "Zmienia warto\:015b\[CAcute] liczby p - procent."}, {0, " "}, {
        2, 
         Row[{
           Style["Czas oprocentowania (lata) = ", 12, 
            GrayLevel[0.2], FontFamily -> "Arial", Plain], 
           Slider[0.5, ImageSize -> Small]}]}, {
        0, "Zmienia waro\:015b\[CAcute] liczby t - czas oprocentowania."}, {
        0, " "}}, G10400601`OPIS[
        Pattern[G10400601`tekst, 
         Blank[]]] := 
      Style[G10400601`tekst, FontFamily -> "Arial", 16, Bold, 
        $CellContext`paletaKolorow[1]], G10400601`TEKST[
        Pattern[G10400601`tekst, 
         Blank[]]] := Style[
        G10400601`styleMark[G10400601`tekst], FontFamily -> "Arial", 
        GrayLevel[0.2], 12, TextAlignment -> Left, LineIndent -> 0], 
      G10400601`styleMark[
        Pattern[G10400601`str, 
         Blank[String]]] := 
      Module[{G10400601`style, 
         G10400601`rules = {
          "***" -> {Plain, Plain}, "**" -> {Bold}, "*" -> {Plain, Italic}, 
           "??" -> {Plain, Plain, Red}}}, G10400601`style[
           Pattern[G10400601`s, 
            Blank[String]], {
            Optional[
             Pattern[G10400601`weight, 
              Blank[]], Plain], 
            Optional[
             Pattern[G10400601`slant, 
              Blank[]], Plain], 
            Optional[
             Pattern[G10400601`color1, 
              Blank[]], True]}] := (StringJoin[
          "\!\(\*StyleBox[\"", G10400601`s, "\", FontWeight -> ", 
           ToString[G10400601`weight], ", FontSlant -> ", 
           ToString[G10400601`slant], 
           SlotSequence[1], "]\)"]& )[
           If[
            TrueQ[G10400601`color1], 
            Unevaluated[], 
            Unevaluated[
             Sequence[", FontColor -> ", 
              ToString[G10400601`color1]]]]]; Composition[StringReplace[#, 
           Apply[StringExpression[#, 
              Shortest[
               Pattern[G10400601`x, 
                BlankSequence[]]], #] :> G10400601`style[G10400601`x, #2]& , 
            G10400601`rules, {1}]]& , StringReplace[#, 
           Apply[Pattern[G10400601`x, 
              StringExpression[#, 
               Shortest[
                BlankSequence[]], #]] :> 
            StringReplace[G10400601`x, "\n" -> StringJoin[#, "\n", #]]& , 
            G10400601`rules, {1}]]& ][G10400601`str]], G10400601`styleMark[{
         Pattern[G10400601`x, 
          Blank[String]], 
         Pattern[G10400601`y, 
          Blank[String]]}] := StringForm[G10400601`x, 
        G10400601`styleMark[G10400601`y]], G10400601`styleMark[{
         Pattern[G10400601`x, 
          Blank[String]], 
         Pattern[G10400601`y, 
          Blank[List]]}] := StringForm[G10400601`x, 
        Apply[Sequence, 
         Map[G10400601`styleMark, G10400601`y]]], G10400601`styleMark[
        Pattern[G10400601`x, 
         BlankNullSequence[]]] := G10400601`x, G10400601`NAGLOWEK[
        Pattern[G10400601`tekst, 
         Blank[]]] := Item[
        Style[
        G10400601`tekst, FontFamily -> "Arial", 18, 
         Bold, $CellContext`KolorPodstawowy], Alignment -> Center, 
        ItemSize -> {Automatic, 5}], G10400601`SEKCJA[
        Pattern[G10400601`tekst, 
         Blank[]]] := (
       Item[#, ItemSize -> {Automatic, 3}, Alignment -> {Left, Center}]& )[
        ToString[
         Style[
          G10400601`styleMark[G10400601`tekst], FontFamily -> "Arial", 15, 
          Bold, $CellContext`KolorPodstawowy, TextAlignment -> Left], 
         StandardForm]], G10400601`WZORY[
        Pattern[G10400601`tekst, 
         Blank[]], 
        Optional[
         Pattern[G10400601`size, 
          Blank[]], 16]] := Item[
        ToString[
         Style[
          G10400601`styleMark[G10400601`tekst], FontFamily -> "Arial", 16, 
          TextAlignment -> Center, Bold], StandardForm], Alignment -> Center],
       G10400601`tekstTeorii = {
       "", "Teoria", {1, "Podstawy teoretyczne"}, {
        0, "\[CapitalCAcute]wiczenie jest ..."}}, G10400601`pokazOpisH[
        Pattern[G10400601`tekstOpisu, 
         Blank[]], 
        Pattern[$CellContext`wymiary, 
         Blank[]], 
        Pattern[G10400601`wymiarywew, 
         Blank[]], 
        Optional[
         Pattern[G10400601`align, 
          Blank[]], Left]] := 
      With[{G10400601`fM = FrameMargins, G10400601`iM = ImageMargins, 
         G10400601`AL = Alignment}, 
        G10400601`tytulOpisu = Part[G10400601`tekstOpisu, 2]; 
        G10400601`trescOpisu = Drop[G10400601`tekstOpisu, 2]; Dynamic[
          G10400601`opisH[
          G10400601`tytulOpisu, G10400601`trescOpisu, $CellContext`wymiary, 
           G10400601`wymiarywew, G10400601`align]]], G10400601`opisH[
        Pattern[G10400601`tytulO, 
         Blank[]], 
        Pattern[G10400601`trescO, 
         Blank[]], 
        Pattern[G10400601`wym, 
         Blank[]], 
        Pattern[G10400601`wymw, 
         Blank[]], 
        Pattern[G10400601`ali, 
         Blank[]]] := Framed[
        (((((Panel[#, Background -> Directive[{
            Opacity[0.8], $CellContext`KolorPodstawowy}], FrameMargins -> 3, 
         ImageMargins -> 0, Alignment -> Center]& )[
         Column[{
           Pane[
            G10400601`OPIS[G10400601`tytulO], Alignment -> G10400601`ali, 
            FrameMargins -> 0, ImageMargins -> 0], #, 
           Item[
            Dynamic[G10400601`WYLACZNIK], Alignment -> Right]}]]& )[
         Panel[#, Background -> $CellContext`paletaKolorow[1], FrameMargins -> 
          0, ImageMargins -> 0, Alignment -> Center]]& )[
         Pane[#, G10400601`wymw, ImageMargins -> 5, Alignment -> Left, 
          Scrollbars -> {False, True}, AppearanceElements -> None]]& )[
         Column[#, Alignment -> Left, ItemSize -> Scaled[1]]]& )[
         Apply[Switch[#, 0, 
           G10400601`TEKST[#2], 1, 
           G10400601`NAGLOWEK[#2], 2, 
           G10400601`SEKCJA[#2], 3, 
           G10400601`WZORY[#2], 4, 
           Item[#2, Alignment -> Center]]& , G10400601`trescO, {1}]], 
        Background -> Directive[{
           Opacity[0.6], White}], ImageSize -> G10400601`wym, Alignment -> 
        Center, FrameStyle -> None], 
      G10400601`tekstHistorii := {"L", "Historia", {2, 
         Column[{
           Row[{
             Dynamic[
              Button[
               Style["Zapisz do schowka", Plain, 14, 
                If[G10400601`aktywnyClpb, 
                 $CellContext`paletaKolorow[0], 
                 $CellContext`paletaKolorow[0.3]]], 
               CopyToClipboard[
                DisplayForm[
                 RowBox[
                  G10400601`clpEx[G10400601`TT]]]], Background -> 
               If[G10400601`aktywnyClpb, $CellContext`KolorPodstawowyJasny, 
                 LightGray], ImageSize -> {150, 25}, Method -> "Queued", 
               Enabled -> G10400601`aktywnyClpb]], 
             Spacer[5], 
             Dynamic[
              Button[
               Style["Wy\:015blij wynik", Plain, 14, 
                $CellContext`paletaKolorow[0]], 
               If[G10400601`wariantUru == 3, 
                G10400601`zapiszHistorie[
                 G10400601`ID[], G10400601`Historia], 
                G10400601`poleKomunikatu = 
                 G10400601`ramkaKomunikatu[
                  0.8 Part[{700, 500}, 1], 100, G10400601`komBlH]; 
                G10400601`warstwa = "Komunikat"; Null], 
               Background -> $CellContext`KolorPodstawowyJasny, 
               ImageSize -> {120, 25}, Method -> "Queued"]], 
             Spacer[5]}], 
           Dynamic[
            Apply[Grid, G10400601`Historia]]}, Alignment -> Right]}}, 
      G10400601`clpEx[
        Pattern[G10400601`T, 
         Blank[]]] := Module[{}, G10400601`xyKlocki = Map[
           Map[{
             Min[
              Part[#, 1], G10400601`stronaX], 
             Part[#, 2]}& , #& ], 
           Map[G10400601`rozmiar, G10400601`T, {2}], {2}]; 
        G10400601`yMax = Join[{0}, 
           Map[Max[
             Map[Part[#, 2]& , #]]& , G10400601`xyKlocki]]; 
        G10400601`xPoz = Map[Join[{0}, #]& , 
           Map[
            Map[Part[#, 1]& , #& ], G10400601`xyKlocki, {2}]]; 
        G10400601`pozycje = Map[Position[{#}, {
             Blank[], 
             Blank[]}, {2}]& , G10400601`xyKlocki]; 
        G10400601`ilePozycji = Map[Length[#]& , G10400601`xyKlocki]; 
        G10400601`ileWierszy = Length[G10400601`ilePozycji]; 
        G10400601`yPoz = Map[Total[
             Part[G10400601`yMax, 
              Span[1, #]]] + Part[G10400601`yMax, # + 1]/2& , 
           Range[G10400601`ileWierszy]]; G10400601`wiersze = {}; 
        G10400601`strony = {}; G10400601`jednaStrona = {}; 
        G10400601`naStronie = 0; G10400601`i = 1; G10400601`ii = 0; 
        G10400601`iiDrop = 0; 
        G10400601`YP = {{
           G10400601`ii, G10400601`yMax, G10400601`iiDrop, G10400601`yPoz, 
            G10400601`naStronie}}; 
        While[G10400601`i <= G10400601`ileWierszy, 
          G10400601`jMax = Part[G10400601`ilePozycji, G10400601`i]; 
          G10400601`obliczWiersz1[G10400601`T]; 
          If[G10400601`naStronie + 
             Part[G10400601`yMax, G10400601`i - G10400601`ii + 1] < 
            G10400601`stronaY, 
            AppendTo[G10400601`jednaStrona, G10400601`wiersze1]; 
            G10400601`naStronie = 
             G10400601`naStronie + 
              Part[G10400601`yMax, G10400601`i - G10400601`ii + 1]; 
            G10400601`wiersze = Join[G10400601`wiersze, {G10400601`wiersze1}]; 
            Null, AppendTo[G10400601`strony, {G10400601`jednaStrona}]; 
            G10400601`jednaStrona = {}; G10400601`ii = G10400601`i - 1; 
            G10400601`yMax = 
             Drop[G10400601`yMax, {2, G10400601`ii + 1 - G10400601`iiDrop}]; 
            G10400601`iiDrop = G10400601`ii; G10400601`yPoz = Map[Total[
                 Part[G10400601`yMax, 
                  Span[1, # - G10400601`ii]]] + 
               Part[G10400601`yMax, # - G10400601`ii + 1]/2& , 
               Range[G10400601`ii + 1, G10400601`ileWierszy]]; 
            G10400601`naStronie = 
             Part[G10400601`yMax, G10400601`i - G10400601`ii + 1]; 
            G10400601`YP = 
             Join[G10400601`YP, {{
                G10400601`ii, G10400601`yMax, G10400601`iiDrop, 
                 G10400601`yPoz, G10400601`naStronie}}]; 
            G10400601`obliczWiersz1[G10400601`T]; 
            AppendTo[G10400601`jednaStrona, G10400601`wiersze1]; Null]; 
          Increment[G10400601`i]]; 
        AppendTo[G10400601`strony, {G10400601`jednaStrona}]; 
        G10400601`rys = 
         Map[Rasterize[#, 
            ImageSize -> {G10400601`stronaX, G10400601`stronaY}]& , 
           Map[
           Graphics[#, ImageSize -> {G10400601`stronaX, G10400601`stronaY}, 
             PlotRange -> {{
               0, G10400601`stronaX}, {-G10400601`stronaY, 0}}]& , 
            G10400601`strony]]; G10400601`rys], G10400601`stronaX = 604, 
      G10400601`rozmiar := ImageDimensions[
        Rasterize[
         Pane[#, {Automatic, Automatic}]]]& , G10400601`obliczWiersz1[
        Pattern[G10400601`T, 
         Blank[]]] := 
      Module[{}, G10400601`j = 1; G10400601`wiersze1 = {}; 
        While[G10400601`j <= G10400601`jMax, 
          G10400601`wiersze1 = Join[G10400601`wiersze1, {
              Inset[
               (Pane[#, {Automatic, Automatic}]& )[
                Part[G10400601`T, G10400601`i, G10400601`j]], {
                Total[
                 Part[
                  Part[G10400601`xPoz, G10400601`i], 
                  Span[1, G10400601`j]]], -
                Part[G10400601`yPoz, G10400601`i - G10400601`ii]}, 
               Scaled[{0, 0.5}]]}]; Increment[G10400601`j]]], 
      G10400601`stronaY = 933, 
      G10400601`TT := (G10400601`parametryObrazkow; 
       Join[{{G10400601`naglowek}}, 
         Map[Module[{}, G10400601`his0 = Part[
              Part[G10400601`Historia, 1], #]; Flatten[{G10400601`centrowanie, 
              If[# == 1, G10400601`his = Map[Framed[
                  G10400601`StA12P[
                   Part[G10400601`his0, #]], ImageSize -> {
                    Part[G10400601`szer, #], 45}, Alignment -> Center, 
                  FrameStyle -> None, 
                  Background -> $CellContext`paletaKolorow[0.9]]& , 
                 Range[
                  Length[G10400601`szer]]], G10400601`his = G10400601`his0]}]; 
           Flatten[{G10400601`centrowanie, 
              Map[Pane[
                Part[G10400601`his, #], {
                 Part[G10400601`szer, #], Automatic}, Alignment -> Center]& , 
               
               Range[
                Length[G10400601`szer]]]}]]& , 
          Range[
           Length[
            Part[G10400601`Historia, 1]]]], {{G10400601`stopka}}]), 
      G10400601`parametryObrazkow := (G10400601`szer = Map[Part[#, 1]& , 
          Map[Rasterize[#, "BoundingBox"]& , 
           Part[
            Part[G10400601`Historia, 1], 1]]]; 
       G10400601`centrowanie = Spacer[
          IntegerPart[(G10400601`stronaX - Total[G10400601`szer])/2]]; Null), 
      G10400601`Historia = {{}}, G10400601`naglowek = Framed[
        Column[{
          Style[
           Image[CompressedData["
1:eJztWEGO2zAMNNpLjwX6gv6i0K3HXrfoA3bReNFLCmQLFP1FXqPP6C+byrFs
kdRIZgw5mwAaYBeRRZPUkKIof376/dC/67ru5YP/9/D49+vh8Pjv+0c/+LF/
+fW83/38tv+ze94dvjy99w8/+b9X/zf8PjU0NDQ0NDQ0NNwLnLO96e2tmbN9
N+B6ji1jrUvuaG5tKRfh3v3HuPKq9OZa5t8M7t1/jJb5erTMDxSYo2Mz89LC
2BhTU2yaF/6Yoz324xu+iXDD8zgk0jY8HWdGZZOpgCA/K4iCm5jjVs8gxPI0
C6NIEtKvjcswPygwUYF13AWBUWXZJUbc4JMV1MWFYoYT0EVKuQVbyjAJ4juv
aFJrzKyU+s8ojgFlnPjZumKSF5RHxqBcRuEcpkDmp5KJX9XMHWVG0KWSNJMZ
nNOvjktegTbzE5fge2FD8czPMrwY3llu2ZZ4EYcpzfxUaeL/KEl/Q4LqimWo
Gff09N60xWlkJv2BG6qRR2UeuZOc3NRcmvixCgXVJD0K+nVM8mM0d6hGBTxn
8y5FpywlBNCIGEa2kYsaW5owoaWGQj/rHM9HsHNJ63PeVqSeyEjUEGMQARND
8J6z/gSMZyRKxcLW38JcvppIV0BZhPqVTM7Kje8UfLBLNTeazrsEEjg9ILjl
lGFgHXUmKlv6MCUayv6T0VSoxl3ixxuKIQY0a2RdMSebrQo34hdTqjXHxzzx
kxQhFBT0q5mkfXJHV8Kts6d5l9DGjwSRRZYYLmdiaSq1tS7zM5sZlisja0po
qURoa4lR4DWKkknrzPki5BxfJcr8Ut9Z0xx7IBKfnr8iXiX9FzLp6MGRttFC
Ou+SuuaXGAZs16r5KExoaZqaz7Yv77+4hrpiKQPLa5wEp+zOd5CkERy7PcLH
Fuboq5nHqe2ifh2Tc8MOCiPochZdurzPRwwjW3Pf3UdzGlsrM5/cnjL+C4pl
l8w01xRj3+UuLcICaWuPv3rgnK1kjj1CrQW4Cxf165hETUeyTRL1eZcyL0JJ
JcPIRb0tRZjgrbnkGKjT4sxLjtR6Yusyn3a1wyWf9wdxrp/v9RPp6Ht+ZXMn
Ut9Apy37/hC0vH4t4azRj+vUZ34ydlb5PV/H8El+z7eEniVbKzPfsxm/+0vH
cOvRsB7a3rdhOxRu1A0bgJ7ojfS3RMv86yLeJhvlb4uW+Q0NJfwHhxwHsw==

            "], "Byte", ColorSpace -> "RGB", ImageResolution -> 72., 
            Interleaving -> True], 16, FontFamily -> "Arial"], 
          Style["Historia \[CAcute]wiczenia", 16, FontFamily -> "Arial"], 
          Style[
           Style[
            Row[{"Symbol \[CAcute]wiczenia: ", G10400601`symbolC}], 14], 16, 
           FontFamily -> "Arial"], 
          Style[
           Style["2021-12-01 08:02:14", 14], 16, FontFamily -> "Arial"]}, 
         Alignment -> Center, Spacings -> 0.3], ImageSize -> {604, Automatic},
         Alignment -> Center], G10400601`StA12P = 
      Style[#, 12, Plain, FontFamily -> "Arial"]& , G10400601`stopka = 
      Column[{"", "", 
         Framed[
          Style[
           Row[{
             Style["\[Copyright]Gambit", 16], 
             Spacer[10], 
             Image[CompressedData["
1:eJztWEGO2zAMNNpLjwX6gv6i0K3HXrfoA3bReNFLCmQLFP1FXqPP6C+byrFs
kdRIZgw5mwAaYBeRRZPUkKIof376/dC/67ru5YP/9/D49+vh8Pjv+0c/+LF/
+fW83/38tv+ze94dvjy99w8/+b9X/zf8PjU0NDQ0NDQ0NNwLnLO96e2tmbN9
N+B6ji1jrUvuaG5tKRfh3v3HuPKq9OZa5t8M7t1/jJb5erTMDxSYo2Mz89LC
2BhTU2yaF/6Yoz324xu+iXDD8zgk0jY8HWdGZZOpgCA/K4iCm5jjVs8gxPI0
C6NIEtKvjcswPygwUYF13AWBUWXZJUbc4JMV1MWFYoYT0EVKuQVbyjAJ4juv
aFJrzKyU+s8ojgFlnPjZumKSF5RHxqBcRuEcpkDmp5KJX9XMHWVG0KWSNJMZ
nNOvjktegTbzE5fge2FD8czPMrwY3llu2ZZ4EYcpzfxUaeL/KEl/Q4LqimWo
Gff09N60xWlkJv2BG6qRR2UeuZOc3NRcmvixCgXVJD0K+nVM8mM0d6hGBTxn
8y5FpywlBNCIGEa2kYsaW5owoaWGQj/rHM9HsHNJ63PeVqSeyEjUEGMQARND
8J6z/gSMZyRKxcLW38JcvppIV0BZhPqVTM7Kje8UfLBLNTeazrsEEjg9ILjl
lGFgHXUmKlv6MCUayv6T0VSoxl3ixxuKIQY0a2RdMSebrQo34hdTqjXHxzzx
kxQhFBT0q5mkfXJHV8Kts6d5l9DGjwSRRZYYLmdiaSq1tS7zM5sZlisja0po
qURoa4lR4DWKkknrzPki5BxfJcr8Ut9Z0xx7IBKfnr8iXiX9FzLp6MGRttFC
Ou+SuuaXGAZs16r5KExoaZqaz7Yv77+4hrpiKQPLa5wEp+zOd5CkERy7PcLH
Fuboq5nHqe2ifh2Tc8MOCiPochZdurzPRwwjW3Pf3UdzGlsrM5/cnjL+C4pl
l8w01xRj3+UuLcICaWuPv3rgnK1kjj1CrQW4Cxf165hETUeyTRL1eZcyL0JJ
JcPIRb0tRZjgrbnkGKjT4sxLjtR6Yusyn3a1wyWf9wdxrp/v9RPp6Ht+ZXMn
Ut9Apy37/hC0vH4t4azRj+vUZ34ydlb5PV/H8El+z7eEniVbKzPfsxm/+0vH
cOvRsB7a3rdhOxRu1A0bgJ7ojfS3RMv86yLeJhvlb4uW+Q0NJfwHhxwHsw==

              "], "Byte", ColorSpace -> "RGB", ImageResolution -> 72., 
              Interleaving -> True], 
             Spacer[10], "31-564 Krak\[OAcute]w, al.Pokoju 29B/22-24"}], 14, 
           FontFamily -> "Arial"], ImageSize -> {604, Automatic}, Alignment -> 
          Center, FrameMargins -> 10]}, Alignment -> Center, Spacings -> 1], 
      G10400601`zapiszHistorie[
        Pattern[G10400601`komp, 
         Blank[]], 
        Pattern[G10400601`hist, 
         Blank[]]] := (
       G10400601`insertOut = 
        DatabaseLink`SQLInsert[
         G10400601`baza, "TabelaDoTestow", {"pole", "tekst"}, {G10400601`komp, 
           ToString[
            InputForm[G10400601`hist]]}]; Null), G10400601`ID[] := Symbol[
        Gambit`GLC["#L`bghmdHC"]], Gambit`GLC := 
      FromCharacterCode[ToCharacterCode[#] + 1]& , G10400601`ramkaKomunikatu[
        Pattern[G10400601`rX, 
         Blank[]], 
        Pattern[G10400601`rY, 
         Blank[]], 
        Pattern[G10400601`tx, 
         Blank[]]] := ((
       Framed[#, ImageSize -> {G10400601`rX, G10400601`rY}, Alignment -> 
        Center, Background -> $CellContext`paletaKolorow[0.2]]& )[
        Framed[#, ImageSize -> {G10400601`rX, G10400601`rY} - {8, 8}, 
         Alignment -> Center, Background -> $CellContext`paletaKolorow[1]]]& )[
        Style[G10400601`tx, 
         $CellContext`paletaKolorow[0.1]]], G10400601`komBlH = Column[{
         Style["Wynik nie mo\:017ce by\[CAcute] wys\[LSlash]any.", 14], 
         Style["U\:017cywane konto nie ma takich uprawnie\:0144.", 14]}], 
      G10400601`pokazK[
        Pattern[$CellContext`wymiary, 
         Blank[]]] := (G10400601`ramkaNaStartStop[#, $CellContext`wymiary]& )[{
         (Style[#, 14, 
          $CellContext`paletaKolorow[0.2], FontFamily -> "Arial"]& )[
         "Rozpoczynamy!"], 
         Button[
          (Style[#, 14, 
           $CellContext`paletaKolorow[1], Bold, FontFamily -> "Arial"]& )[
          "Start \[CAcute]wiczenia"], G10400601`wiatrak = True; 
          G10400601`cwiczenieStart[]; G10400601`wiatrak = False; Null, Method -> 
          "Queued", Appearance -> "DialogBox", 
          Background -> $CellContext`paletaKolorow[0.4], 
          ImageSize -> {165, 30}]}], G10400601`ramkaNaStartStop[
        Pattern[G10400601`coWRamce, 
         Blank[]], 
        Pattern[$CellContext`wymiary, 
         Blank[]]] := Framed[
        Framed[
         Column[
          Flatten[{
            (
            Panel[#, FrameMargins -> 5, ImageMargins -> 0, Alignment -> 
             Center, Background -> Lighter[
               $CellContext`paletaKolorow[1], 0.5]]& )[
             (
             Framed[#, ImageSize -> {155, 155}, Alignment -> Center, 
              Background -> Lighter[Gray, 0.9], FrameStyle -> {
                Lighter[Gray, 0.8], 
                Thickness[3]}]& )[
              Dynamic[
               Deploy[
                If[
                 Not[G10400601`wiatrak], G10400601`Logo150, 
                 ProgressIndicator[
                 Appearance -> "Necklace", ImageSize -> 70]]]]]], 
            G10400601`coWRamce}], Alignment -> Center], Background -> 
         Lighter[
           $CellContext`paletaKolorow[1], 0.5], Alignment -> Center, 
         FrameStyle -> {
           $CellContext`paletaKolorow[0.3], 
           Thickness[3]}], ImageSize -> $CellContext`wymiary, Background -> 
        Directive[{
           Opacity[0.5], White}], Alignment -> Center, FrameStyle -> None], 
      G10400601`wiatrak = False, G10400601`Logo150 := 
      With[{G10400601`opacity = 0.9, 
         G10400601`kolor = $CellContext`paletaKolorow[0.9]}, 
        DynamicModule[{}, 
         Deploy[
          Graphics3D[{
            EdgeForm[{Thick, G10400601`kolor}], 
            GraphicsComplex[G10400601`pts, {G10400601`kolor, 
              Opacity[G10400601`opacity], 
              FaceForm[
               Texture[G10400601`tex]], 
              Polygon[
              G10400601`vv, VertexTextureCoordinates -> 
               Table[G10400601`vtc, {6}]]}]}, Lighting -> "Neutral", Boxed -> 
           False, ImageSize -> {150, 150}, 
           Method -> {"RotationControl" -> "Globe"}, RotationAction -> "Clip",
            ViewPoint -> Dynamic[
             
             With[{G10400601`p = 
               2 MousePosition[{"Graphics", DynamicModule}, {2, 0}]}, 
              G10400601`pPP = G10400601`p; 22 {(-Cos[
                    Part[G10400601`p, 1]]) Sin[
                   Part[G10400601`p, 2]], Sin[
                   Part[G10400601`p, 1]] Sin[
                   Part[G10400601`p, 2]], 
                 Cos[
                  Part[G10400601`p, 2]]}]]]], SaveDefinitions -> True, 
         Initialization -> (G10400601`pts = G10400601`pts0; 
          G10400601`vv = G10400601`vv0; G10400601`vtc = G10400601`vtc0; 
          G10400601`tex = G10400601`tex0; Null)]], 
      G10400601`cwiczenieStart[] := (G10400601`typDostepu = 0; 
       G10400601`czekajNaSQL = True; G10400601`czyJestPolaczenie = False; 
       G10400601`wariantUru = 1; G10400601`uzytkownik = "Brak danych"; 
       G10400601`polacz[]; 
       If[G10400601`czyJestPolaczenie, G10400601`czytajTWLB; 
         G10400601`wariantUruchomienia; G10400601`tempVectorPointPlot; 
         If[G10400601`parBazyPTec == "1", G10400601`warstwa = "Przerwa"; 
           Null], G10400601`ktoraProbaLaczenia = 
          G10400601`ktoraProbaLaczenia + 1; G10400601`warstwa = "BrakDostepu"; 
         Null]; G10400601`odlT = 0; 
       If[G10400601`wariantUru == 1, G10400601`odliczanie = SessionSubmit[
            ScheduledTask[
             If[
             G10400601`odlT >= G10400601`oCzasu, G10400601`warstwa = "Koniec",
               G10400601`odlT = G10400601`odlT + 1, 1; Null], 1]]; Null]; If[
         And[
          Or[G10400601`typDostepu == 1, G10400601`typDostepu == 2], 
          G10400601`parBazyPTec != "1"], G10400601`warstwa = "Opis"; Null]; 
       Null), G10400601`czytajTWLB := (G10400601`parametryDostepu = Part[
          DatabaseLink`SQLSelect[
          G10400601`baza, "Parametry", DatabaseLink`SQLColumn["IdP"] == 1], 
          1]; G10400601`dataWL = DateObject[
          Part[G10400601`parametryDostepu, 2]]; {
         G10400601`parBazySerw, G10400601`parBazyRoPS, G10400601`parBazyPTec, 
          G10400601`parBazyPDoD, G10400601`parBazyPDoG, G10400601`parBazyPKom,
           G10400601`parBazyRekl, G10400601`parBazyROdK, 
          G10400601`parBazyRDoK, G10400601`parBazyRTre} = 
        Part[G10400601`parametryDostepu, 
          Span[3, 12]]; Null), G10400601`parBazyPDoD = "", 
      G10400601`parBazyPDoG = "", 
      G10400601`wariantUruchomienia := (G10400601`idK = G10400601`ID[]; 
       G10400601`czytajRekordyIdK[G10400601`idK]; 
       G10400601`aktywnyClpb = False; Which[
         MatchQ[G10400601`rekordyIdK, {}], G10400601`wariantUru = 1; 
         G10400601`uzytkownik = "Brak danych"; Null, 
         And[Length[G10400601`rekordyIdK] == 1, Part[
            Part[G10400601`rekordyIdK, 1], 7] != G10400601`parBazySerw], 
         G10400601`wariantUru = 2; G10400601`uzytkownik = StringJoin[
            Part[
             Part[G10400601`rekordyIdK, 1], 8], " ", 
            Part[
             Part[G10400601`rekordyIdK, 1], 9]]; 
         G10400601`aktywnyClpb = Part[
             Part[G10400601`rekordyIdK, 1], 31] == "1", 
         And[Length[G10400601`rekordyIdK] == 1, Part[
            Part[G10400601`rekordyIdK, 1], 7] == G10400601`parBazySerw, 
          G10400601`parBazyRoPS == 0], G10400601`wariantUru = 2; 
         G10400601`uzytkownik = StringJoin[
            Part[
             Part[G10400601`rekordyIdK, 1], 8], " ", 
            Part[
             Part[G10400601`rekordyIdK, 1], 9]]; 
         G10400601`aktywnyClpb = Part[
             Part[G10400601`rekordyIdK, 1], 31] == "1", 
         And[Length[G10400601`rekordyIdK] == 1, Part[
            Part[G10400601`rekordyIdK, 1], 7] == G10400601`parBazySerw, 
          G10400601`parBazyRoPS == 1], G10400601`wariantUru = 1; 
         G10400601`uzytkownik = "Serwisant"; G10400601`oCzasu = 20; Null, 
         Length[G10400601`rekordyIdK] >= 2, G10400601`wariantUru = 1; 
         G10400601`uzytkownik = "Brak jednoznacznego wskazania"; Null]; Null),
       G10400601`czytajRekordyIdK[
        Pattern[G10400601`idk, 
         Blank[]]] := (G10400601`rekordyIdK = 
       DatabaseLink`SQLSelect[
        G10400601`baza, "klienci", DatabaseLink`SQLColumn["idkomp"] == 
         G10400601`idk]), G10400601`ktoraProbaLaczenia = 1, 
      Attributes[ScheduledTask] = {HoldAll}, 
      TagSetDelayed[ScheduledTask, 
       CloudDeploy[
        Pattern[CloudObject`Private`task, 
         Blank[ScheduledTask]], 
        Pattern[CloudObject`Private`co, 
         Blank[CloudObject]], 
        Pattern[CloudObject`Private`opts, 
         OptionsPattern[]]], 
       Catch[
        CloudObject`Private`iCloudDeployScheduledTask[
        CloudObject`Private`task, CloudObject`Private`co, 
         CloudObject`Private`opts], CloudObject`Private`$tag]], 
      Options[ScheduledTask] = {
       AutoRemove -> False, NotificationFunction -> Automatic, TimeZone -> 
        Automatic}, 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "ambig"], 
       "Timespec `` is ambiguous; try explicitly specifying start and end \
times."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "argu"], 
       "Unrecognized scheduling specification."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "badarg"], 
       "Bad value `1` for argument `2`."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "copied"], 
       "Local file `1` copied to `2` for cloud execution."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "crea"], 
       "Unable to create scheduled task."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "inact"], 
       "Scheduled task `1` is inactive."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "listing"], 
       "Unable to obtain ScheduledTask listing."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "noavil"], 
       "Scheduling tasks remotely is not yet available."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "nonext"], 
       "Unable to obtain next scheduled run time for ScheduledTask `1`."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "norm"], 
       "Unable to remove ScheduledTask `1`."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "norun"], 
       "Scheduled task `1` is not presently running."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "nostart"], 
       "Unable to start ScheduledTask."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "nostop"], 
       "Unable to stop ScheduledTask `1`."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "notask"], 
       "Argument 1 in CloudDeploy is not a recognized ScheduledTask \
specification."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "nouri"], 
       "Unrecognized uri specificiation `1`."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "optx"], "Unknown option `1` in `2`."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "restr"], 
       "Use restricted under current subscription."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "rstsch"], 
       "Scheduling frequency is restricted on current cloud. Using \"Hourly\" \
instead."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "sched"], 
       "`1` is not a recognized scheduling time specification."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "tasknf"], "No task found at `1`."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "unsuppsched"], 
       "The scheduling time specification `1` is not supported by the target \
environment."], 
      TagSet[ScheduledTask, 
       MessageName[ScheduledTask, "upda"], 
       "Unable to update scheduled task."], 
      CloudObject`Private`iCloudDeployScheduledTask[
        Pattern[CloudObject`Private`st, 
         ScheduledTask[
          Pattern[CloudObject`Private`expr, 
           Blank[]], 
          Pattern[CloudObject`Private`sched, 
           Blank[]], 
          Pattern[CloudObject`Private`o, 
           OptionsPattern[]]]], 
        Pattern[CloudObject`Private`obj, 
         CloudObject[
          Pattern[CloudObject`Private`uri, 
           Blank[String]], 
          BlankNullSequence[]]], 
        Pattern[CloudObject`Private`deploymentOptions, 
         OptionsPattern[]]] := 
      Module[{CloudObject`Private`cloud, CloudObject`Private`uuid, 
         CloudObject`Private`name, CloudObject`Private`continuous = TrueQ[
           Lookup[
            Flatten[{CloudObject`Private`o}], "Continuous", False]], 
         CloudObject`Private`runImmediately = False, 
         CloudObject`Private`cronned, CloudObject`Private`params, 
         CloudObject`Private`opts = Flatten[{CloudObject`Private`o}], 
         CloudObject`Private`endpoint, CloudObject`Private`taskJson, 
         CloudObject`Private`rJson, CloudObject`Private`deployOpts}, 
        If[$CloudUserID === None, CloudConnect[]; If[
            Not[
             TrueQ[$CloudConnected]], Message[
              MessageName[CloudDeploy, "notauth"]]; Return[$Failed]]]; {
          CloudObject`Private`cloud, CloudObject`Private`uuid, 
           CloudObject`Private`name} = 
         CloudObject`Private`getCloudUUIDAndPathForTask[
          CloudObject`Private`obj]; {
          CloudObject`Private`runImmediately, CloudObject`Private`cronned} = 
         Which[CloudObject`Private`continuous, {True, 
            CloudObject`Private`resolveTimespec[ScheduledTask, 
             ReleaseHold[CloudObject`Private`sched]]}, 
           CloudObject`Private`nowQ[CloudObject`Private`sched], {True, 
            CloudObject`Private`resolveTimespec[ScheduledTask, None]}, True, {
           False, 
            CloudObject`Private`resolveTimespec[ScheduledTask, 
             ReleaseHold[CloudObject`Private`sched]]}]; 
        CloudObject`Private`cronned = 
         ReplaceAll[CloudObject`Private`cronned, {None -> Null}]; 
        CloudObject`Private`deployOpts = Join[
           Flatten[{CloudObject`Private`deploymentOptions}], 
           Options[CloudDeploy]]; 
        CloudObject`Private`taskJson = 
         CloudObject`Private`generateTaskJson[
          CloudObject`Private`st, {
           CloudObject`Private`name, CloudObject`Private`uuid}, 
           CloudObject`Private`cronned, 
           Join[
           CloudObject`Private`opts, {
            "RunImmediately" -> CloudObject`Private`runImmediately}], 
           CloudObject`Private`deployOpts]; 
        If[CloudObject`Private`taskJson === $Failed, 
          Throw[$Failed, CloudObject`Private`$tag]]; 
        CloudObject`Private`params = 
         CloudObject`Private`exportToJSON[{
           "task" -> CloudObject`Private`taskJson}]; 
        If[CloudObject`Private`params === $Failed, 
          Throw[$Failed, CloudObject`Private`$tag]]; 
        CloudObject`Private`endpoint = If[
           CloudObject`Private`scheduledTaskQ[CloudObject`Private`obj], {
           "tasks", 
            Last[
             CloudObject`Private`safeCloudAndUUIDFetch[
             CloudObject`Private`obj, ScheduledTask]]}, {"tasks"}]; 
        With[{CloudObject`Private`mh = ScheduledTask}, 
          CloudObject`Private`rJson = Replace[
             CloudObject`Private`execute[
             CloudObject`Private`cloud, "POST", CloudObject`Private`endpoint, 
              CloudObject`Private`Body -> 
              ToCharacterCode[CloudObject`Private`params, "UTF-8"]], {{
                Blank[String], 
                Pattern[CloudObject`Private`content, 
                 Blank[List]]} :> (CloudObject`Private`$lastInfoJSON = 
               FromCharacterCode[CloudObject`Private`content]), 
              CloudObject`Private`HTTPError[400, 
                Pattern[CloudObject`Private`content, 
                 Blank[]], 
                BlankNullSequence[]] :> (
               With[{CloudObject`Private`json = 
                  CloudObject`Private`importFromJSON[
                   CloudObject`Private`content]}, 
                 CloudObject`Private`handleTaskErrorMessage[
                   Lookup[CloudObject`Private`json, "error"], 
                   CloudObject`Private`mh]; 
                 Throw[$Failed, CloudObject`Private`$tag]]; Null), 
              CloudObject`Private`HTTPError[403, 
                Pattern[CloudObject`Private`content, 
                 Blank[]], 
                BlankNullSequence[]] :> (ToExpression[
                 Lookup[
                  CloudObject`Private`importFromJSON[
                  CloudObject`Private`content], "error", 
                  "ScheduledTask::restr"], InputForm, Message]; 
               Throw[$Failed, CloudObject`Private`$tag]), 
              Pattern[CloudObject`Private`other, 
                Blank[]] :> (Message[
                 MessageName[CloudObject`Private`mh, "srverr"]]; Message[
                 MessageName[CloudObject`Private`mh, "crea"]]; 
               Throw[$Failed, CloudObject`Private`$tag])}]; Null]; 
        CloudObject`Private`obj], 
      CloudObject`Private`iCloudDeployScheduledTask[
        ScheduledTask[
         Pattern[CloudObject`Private`args, 
          BlankNullSequence[]]], 
        BlankNullSequence[]] := (ArgumentCountQ[ScheduledTask, 
         Length[
          DeleteCases[{CloudObject`Private`args}, 
           Alternatives[
            Blank[Rule], 
            Blank[RuleDelayed]], Infinity]], 2, 2]; $Failed), 
      CloudObject`Private`iCloudDeployScheduledTask[
        BlankNullSequence[]] := $Failed, 
      CloudObject`Private`getCloudUUIDAndPathForTask[
        Pattern[CloudObject`Private`obj, 
         Blank[CloudObject]]] := 
      Module[{CloudObject`Private`cloud, CloudObject`Private`uuid, 
         CloudObject`Private`name}, {
          CloudObject`Private`cloud, CloudObject`Private`uuid, 
           CloudObject`Private`name} = Replace[
           CloudObject`Private`getCloudAndUUIDOrPath[CloudObject`Private`obj],
            None -> Null, {1}]; 
        CloudObject`Private`name = 
         Replace[CloudObject`Private`name, {Pattern[CloudObject`Private`n, {
               StringExpression["user-", $CloudUserUUID], 
               BlankSequence[]}] :> FileNameJoin[
              Rest[CloudObject`Private`n], OperatingSystem -> "Unix"], 
            Pattern[CloudObject`Private`n, {$UserURLBase, 
               BlankSequence[]}] :> FileNameJoin[
              Rest[CloudObject`Private`n], OperatingSystem -> "Unix"], 
            Pattern[CloudObject`Private`n, 
              Blank[List]] :> 
            FileNameJoin[
             CloudObject`Private`n, OperatingSystem -> "Unix"]}]; {
         CloudObject`Private`cloud, CloudObject`Private`uuid, 
          CloudObject`Private`name}], 
      CloudObject`Private`getCloudAndUUIDOrPath[
        Pattern[CloudObject`Private`uriwrapper, 
         Alternatives[
          Blank[URL], 
          Blank[Hyperlink]]]] := CloudObject`Private`getCloudAndUUIDOrPath[
        CloudObject[CloudObject`Private`uriwrapper]], 
      CloudObject`Private`getCloudAndUUIDOrPath[
        Pattern[CloudObject`Private`obj, 
         CloudObject[
          Pattern[CloudObject`Private`uri, 
           Blank[String]], 
          BlankNullSequence[]]]] := 
      CloudObject`Private`getCloudAndUUIDOrPath[CloudObject`Private`uri], 
      CloudObject`Private`getCloudAndUUIDOrPath[
        Pattern[CloudObject`Private`uri, 
         Blank[String]]] := 
      Module[{CloudObject`Private`cloud, CloudObject`Private`uuid, 
         CloudObject`Private`user, CloudObject`Private`path, 
         CloudObject`Private`ext, CloudObject`Private`extraPath, 
         CloudObject`Private`search, 
         CloudObject`Private`urlType}, {
          CloudObject`Private`cloud, CloudObject`Private`uuid, 
           CloudObject`Private`user, CloudObject`Private`path, 
           CloudObject`Private`ext, CloudObject`Private`extraPath, 
           CloudObject`Private`search, CloudObject`Private`urlType} = 
         CloudObject`Private`parseURI[CloudObject`Private`uri]; 
        If[CloudObject`Private`extraPath === {}, {
          CloudObject`Private`cloud, CloudObject`Private`uuid, 
           If[CloudObject`Private`path === None, None, 
            Join[{CloudObject`Private`user}, CloudObject`Private`path]]}, 
          If[
          CloudObject`Private`uuid === None, {CloudObject`Private`cloud, None, 
            
            Join[{CloudObject`Private`user}, CloudObject`Private`path, 
             CloudObject`Private`extraPath]}, {
           CloudObject`Private`cloud, None, 
            
            Join[{CloudObject`Private`uuid}, 
             CloudObject`Private`extraPath]}]]], 
      CloudObject`Private`parseURI[
        Pattern[CloudObject`Private`uri, 
         Blank[String]], 
        Pattern[CloudObject`Private`opts, 
         OptionsPattern[]]] := 
      CloudObject`Private`parseURI[
       CloudObject`Private`uri, $CloudBase, CloudObject`Private`opts], 
      CloudObject`Private`parseURI[
        CloudObject[
         Pattern[CloudObject`Private`uri, 
          Blank[String]], 
         BlankNullSequence[]], 
        Pattern[CloudObject`Private`rest, 
         BlankNullSequence[]]] := 
      CloudObject`Private`parseURI[
       CloudObject`Private`uri, CloudObject`Private`rest], 
      CloudObject`Private`parseURI[
        Pattern[CloudObject`Private`uri, 
         Blank[String]], 
        Pattern[CloudObject`Private`base, 
         Blank[String]], 
        Pattern[CloudObject`Private`opts, 
         OptionsPattern[]]] := 
      CloudObject`Private`parseURI[
       CloudObject`Private`uri, CloudObject`Private`base, $UserURLBase, 
        Hold[$CloudRootDirectory], 
        Hold[CloudObject`Private`$CloudDirectory], 
        CloudObject`Private`$objRoot, 
        Part[
         StringSplit[CloudObject`Private`$CloudFilesRoot, "/", All], 2], 
        "objects", CloudObject`Private`opts], CloudObject`Private`parseURI[
        Pattern[CloudObject`Private`uri, 
         Blank[String]], 
        Pattern[CloudObject`Private`currentCloud, 
         Blank[]], 
        Pattern[CloudObject`Private`currentUser, 
         Blank[]], 
        Pattern[CloudObject`Private`rootDir, 
         Blank[]], 
        Pattern[CloudObject`Private`currentDir, 
         Blank[]], 
        Pattern[CloudObject`Private`objRoot, 
         Blank[]], 
        Pattern[CloudObject`Private`filesRoot, 
         Blank[]], 
        Pattern[CloudObject`Private`objectsRoot, 
         Blank[]], 
        Pattern[CloudObject`Private`opts, 
         OptionsPattern[]]] := 
      Module[{CloudObject`Private`protocol, CloudObject`Private`host, 
         CloudObject`Private`port, CloudObject`Private`pathname, 
         CloudObject`Private`baseobj, CloudObject`Private`basepath, 
         CloudObject`Private`search, CloudObject`Private`cloudprefix, 
         CloudObject`Private`request, CloudObject`Private`nameFormat, 
         CloudObject`Private`urlType, CloudObject`Private`cloud = 
         CloudObject`Private`currentCloud, CloudObject`Private`user = 
         CloudObject`Private`currentUser, CloudObject`Private`formatNameQ = 
         True, CloudObject`Private`handleURLTypeQ = True, 
         CloudObject`Private`uuid = None, CloudObject`Private`path = None, 
         CloudObject`Private`ext = None, 
         CloudObject`Private`extraPath = {}}, {
          CloudObject`Private`protocol, CloudObject`Private`host, 
           CloudObject`Private`port, CloudObject`Private`pathname, 
           CloudObject`Private`search} = 
         URLParse[
          CloudObject`Private`uri, {
           "Scheme", "Domain", "Port", "Path", "Query"}]; 
        CloudObject`Private`log[
         "Parsed URL: `1`", {
          CloudObject`Private`protocol, CloudObject`Private`host, 
           CloudObject`Private`port, CloudObject`Private`pathname, 
           CloudObject`Private`search}, CloudObject`Private`DebugLevel -> 4]; 
        CloudObject`Private`nameFormat = OptionValue[CloudObjectNameFormat]; 
        CloudObject`Private`urlType = OptionValue[CloudObjectURLType]; 
        CloudObject`Private`request = 
         FileNameDrop[
          CloudObject`Private`$CloudObjectsRoot, 1, OperatingSystem -> 
           "Unix"]; If[
          MemberQ[{"http", "https"}, CloudObject`Private`protocol], 
          If[CloudObject`Private`urlType === Automatic, 
            CloudObject`Private`handleURLTypeQ = False]; 
          If[CloudObject`Private`nameFormat === Automatic, 
            CloudObject`Private`formatNameQ = False]; Null]; 
        If[CloudObject`Private`protocol === None, 
          CloudObject`Private`formatNameQ = True; 
          CloudObject`Private`baseobj = If[
             And[
             Length[CloudObject`Private`pathname] >= 1, 
              First[CloudObject`Private`pathname] === ""], 
             CloudObject`Private`pathname = 
              Rest[CloudObject`Private`pathname]; CloudObject`Private`rootDir,
              CloudObject`Private`currentDir]; {
            CloudObject`Private`protocol, CloudObject`Private`host, 
             CloudObject`Private`port, CloudObject`Private`basepath} = 
           URLParse[
             CloudObject`Private`extractURL[
              ReleaseHold[CloudObject`Private`baseobj]], {
             "Scheme", "Domain", "Port", "Path"}]; 
          CloudObject`Private`pathname = 
           Join[CloudObject`Private`basepath, CloudObject`Private`pathname]]; 
        CloudObject`Private`log[
         "Parsing URI `1`", {
          CloudObject`Private`protocol, CloudObject`Private`host, 
           CloudObject`Private`port, CloudObject`Private`pathname, 
           CloudObject`Private`search}, CloudObject`Private`DebugLevel -> 4]; 
        Switch[CloudObject`Private`protocol, 
          Alternatives["uuid", "wolfram"], 
          If[
           And[
           CloudObject`Private`host === None, 
            Length[CloudObject`Private`pathname] >= 
            1], {CloudObject`Private`uuid, CloudObject`Private`ext} = 
            CloudObject`Private`checkUUID[
              First[CloudObject`Private`pathname]]; 
           CloudObject`Private`extraPath = 
            Rest[CloudObject`Private`pathname]], "user", 
          If[
           And[
           CloudObject`Private`host === None, 
            Length[CloudObject`Private`pathname] >= 1], 
           CloudObject`Private`user = 
            CloudObject`Private`processCloudObjectNameFormat[
              StringJoin["user:", 
               First[CloudObject`Private`pathname]], 
              CloudObject`Private`nameFormat]; 
           CloudObject`Private`formatNameQ = False; 
           CloudObject`Private`path = Rest[CloudObject`Private`pathname]], 
          Alternatives["http", "https", None], If[
            And[
            CloudObject`Private`protocol =!= None, CloudObject`Private`host =!= 
             None], CloudObject`Private`cloud = 
             URLBuild[{
               "Scheme" -> CloudObject`Private`protocol, "Domain" -> 
                CloudObject`Private`host, "Port" -> 
                CloudObject`Private`port}]; If[
              Or[
              CloudObject`Private`pathname === {}, 
               First[CloudObject`Private`pathname] =!= ""], 
              PrependTo[CloudObject`Private`pathname, ""]]]; 
          CloudObject`Private`log[
           "Path `1` (object root: `2`, files root: `3`)", 
            CloudObject`Private`pathname, CloudObject`Private`objRoot, 
            CloudObject`Private`filesRoot, CloudObject`Private`DebugLevel -> 
            4]; If[
            MatchQ[CloudObject`Private`pathname, {
              BlankNullSequence[], 
              Alternatives[
              CloudObject`Private`$ViewPattern, 
               CloudObject`Private`filesRoot], 
              BlankSequence[]}], {
              CloudObject`Private`cloudprefix, CloudObject`Private`request, 
               CloudObject`Private`pathname} = 
             Replace[CloudObject`Private`pathname, {
                 Shortest[
                  Pattern[CloudObject`Private`prefix, 
                   BlankNullSequence[]]], 
                 Pattern[CloudObject`Private`type, 
                  Alternatives[
                  CloudObject`Private`$ViewPattern, 
                   CloudObject`Private`filesRoot]], 
                 Pattern[CloudObject`Private`rest, 
                  BlankNullSequence[]]} :> {{CloudObject`Private`prefix}, 
                 CloudObject`Private`type, {CloudObject`Private`rest}}]; If[
              And[
               StringMatchQ[CloudObject`Private`cloud, 
                StringExpression[
                 BlankNullSequence[], "/"]], 
               CloudObject`Private`cloudprefix =!= {}, 
               First[CloudObject`Private`cloudprefix] === ""], 
              CloudObject`Private`cloud = 
              StringDrop[CloudObject`Private`cloud, -1]]; 
            CloudObject`Private`cloud = 
             StringJoin[CloudObject`Private`cloud, 
               StringJoin[
                Riffle[CloudObject`Private`cloudprefix, "/"]]]; 
            If[CloudObject`Private`request === CloudObject`Private`filesRoot, 
              CloudObject`Private`request = CloudObject`Private`objRoot; 
              AppendTo[CloudObject`Private`search, "view" -> "file"]]; If[
              CloudObject`UUIDQ[
               First[CloudObject`Private`pathname]], 
              CloudObject`Private`log[
               "UUID-based URI: `1`", CloudObject`Private`pathname, 
                CloudObject`Private`DebugLevel -> 4]; {
                CloudObject`Private`uuid, CloudObject`Private`ext} = 
               CloudObject`ParseUUID[
                 First[CloudObject`Private`pathname]]; 
              CloudObject`Private`extraPath = 
               Rest[CloudObject`Private`pathname], 
              CloudObject`Private`log[
               "Username-based URI `1`", CloudObject`Private`pathname, 
                CloudObject`Private`DebugLevel -> 4]; 
              CloudObject`Private`user = First[CloudObject`Private`pathname]; 
              If[
                Or[CloudObject`Private`user === "~", 
                 And[
                  TrueQ[CloudObject`Private`formatNameQ], 
                  CloudObject`Private`nameFormat =!= "UUID"]], 
                If[CloudObject`Private`currentUser === None, 
                  CloudConnect[]]; 
                CloudObject`Private`user = 
                 CloudObject`Private`processCloudObjectNameFormat[
                  CloudObject`Private`user, 
                   CloudObject`Private`userFormat[
                   CloudObject`Private`nameFormat]]; 
                CloudObject`Private`user = 
                 Replace[CloudObject`Private`user, Alternatives[$Failed, 
                    Except[
                    Blank[String]]] -> None]; Null]; 
              CloudObject`Private`log[
               "User: `1`", CloudObject`Private`user, 
                CloudObject`Private`DebugLevel -> 3]; 
              CloudObject`Private`path = Rest[CloudObject`Private`pathname]; 
              Null]]]; CloudObject`Private`urlType = 
         If[CloudObject`Private`handleURLTypeQ, 
           CloudObject`Private`handleCloudObjectURLType[
           CloudObject`Private`urlType, CloudObject], 
           CloudObject`Private`request]; 
        CloudObject`Private`log[
         "Parsed URI: `1`", {
          CloudObject`Private`cloud, CloudObject`Private`uuid, 
           CloudObject`Private`user, CloudObject`Private`path, 
           CloudObject`Private`ext, CloudObject`Private`extraPath, 
           CloudObject`Private`search, CloudObject`Private`urlType}, 
          CloudObject`Private`DebugLevel -> 4]; {
         CloudObject`Private`cloud, CloudObject`Private`uuid, 
          CloudObject`Private`user, CloudObject`Private`path, 
          CloudObject`Private`ext, CloudObject`Private`extraPath, 
          CloudObject`Private`search, CloudObject`Private`urlType}], 
      Options[CloudObject`Private`parseURI] = {
       CloudObjectNameFormat -> Automatic, CloudObjectURLType -> Automatic}, 
      Attributes[$CloudBase] = {ReadProtected}, 
      CloudObject`Private`$CloudDirectory := Quiet[
        CloudObject[
         CloudObject`JoinURL[{$CloudBase, 
           CloudObject`Private`$CloudObjectsRoot, "~"}]]], CloudObject`JoinURL[
        Pattern[CloudObject`Private`items, 
         BlankSequence[]]] := StringJoin[
        Riffle[
         Map[StringTrim[#, "/"]& , 
          DeleteCases[
           Flatten[{CloudObject`Private`items}], ""]], "/"]], 
      CloudObject`Private`$CloudObjectsRoot = "/obj", 
      CloudObject`Private`$CloudFilesRoot = "/files", 
      Attributes[CloudObject`Private`log] = {HoldRest}, 
      CloudObject`Private`log[
        Pattern[CloudObject`Private`msg, 
         Blank[String]], 
        Shortest[
         Pattern[CloudObject`Private`args, 
          BlankNullSequence[]]], 
        OptionsPattern[]] := If[
        And[
        CloudObject`$CloudDebug, CloudObject`Private`$CloudDebugLevel >= 
         OptionValue[CloudObject`Private`DebugLevel]], 
        Print[
         ToString[
          StringForm[CloudObject`Private`msg, CloudObject`Private`args]]]], 
      Options[CloudObject`Private`log] = {
       CloudObject`Private`DebugLevel -> 1}, CloudObject`$CloudDebug = False, 
      CloudObject`Private`$CloudDebugLevel = 2, 
      TagSet[CloudObject`Private`DebugLevel, 
       MessageName[CloudObject`Private`DebugLevel, "usage"], 
       "DebugLevel is an option to log."], CloudObject`Private`extractURL[
        CloudObject[
         Pattern[CloudObject`Private`uri, 
          Blank[String]], 
         BlankNullSequence[]]] := CloudObject`Private`uri, 
      CloudObject`Private`extractURL[
        Pattern[CloudObject`Private`uri, 
         Blank[String]]] := CloudObject`Private`uri, 
      CloudObject`Private`checkUUID[
        Pattern[CloudObject`Private`uuid, 
         Blank[]]] := If[
        StringMatchQ[
        CloudObject`Private`uuid, CloudObject`Private`uuidRegex], {
        CloudObject`Private`uuid, None}, 
        CloudObject`Private`cloudObjectFailureObject[
        "invuuid", CloudObject`Private`uuid]], CloudObject`Private`uuidRegex = 
      StringExpression[
        RegularExpression["[0-9a-fA-F]{8}\\-[0-9a-fA-F]{4}"], "-4", 
        RegularExpression[
        "[0-9a-fA-F]{3}\\-[0-9a-fA-F]{4}\\-[0-9a-fA-F]{12}"]], 
      CloudObject`Private`cloudObjectFailureObject[
        Pattern[CloudObject`Private`uri, 
         Blank[String]]] := (Message[
         MessageName[CloudObject, "invpath"], CloudObject`Private`uri]; Return[
         Failure["CloudObjectInvalidPathFailure", 
          Association[
          "MessageTemplate" -> MessageName[CloudObject, "invpath"], 
           "MessageParameters" -> {CloudObject`Private`uri}]]]), 
      CloudObject`Private`cloudObjectFailureObject["invuuid", 
        Pattern[CloudObject`Private`uuid, 
         Blank[String]]] := (Message[
         MessageName[CloudObject, "invuuid"], CloudObject`Private`uuid]; Throw[
         Failure["CloudObjectInvalidUUID", 
          Association[
          "MessageTemplate" -> MessageName[CloudObject, "invuuid"], 
           "MessageParameters" -> {CloudObject`Private`uuid}]], 
         CloudObject`Private`InvUUID]), 
      CloudObject`Private`cloudObjectFailureObject["invhyperlink", 
        Pattern[CloudObject`Private`link, 
         Blank[]]] := (Message[
         MessageName[CloudObject, "invhyperlink"], CloudObject`Private`link]; 
       Throw[
         Failure["CloudObjectInvalidHyperlink", 
          Association[
          "MessageTemplate" -> MessageName[CloudObject, "invhyperlink"], 
           "MessageParameters" -> {CloudObject`Private`link}]], 
         CloudObject`Private`InvHyperlink]), 
      CloudObject`Private`processCloudObjectNameFormat[
        PatternTest[
         Pattern[CloudObject`Private`user, 
          Blank[]], CloudObject`Private`userProtocolQ], 
        Pattern[CloudObject`Private`format, 
         Alternatives[
         "UUID", "UserURLBase", "CloudUserID", "CloudUserUUID", "Literal", 
          Automatic]]] := 
      Module[{CloudObject`Private`userNew, CloudObject`Private`res}, 
        Catch[
        CloudObject`Private`userNew = 
          StringReplace[CloudObject`Private`user, StringExpression["user:", 
              Pattern[CloudObject`Private`name, 
               BlankSequence[]]] :> CloudObject`Private`name]; 
         CloudObject`Private`res = 
          CloudObject`Private`userSpecificationFromNameFormat[
           CloudObject`Private`userNew, CloudObject`Private`format]; 
         If[CloudObject`Private`res === None, If[
             Not[
              MemberQ[{Automatic, "Literal"}, CloudObject`Private`format]], 
             Message[
              MessageName[CloudObjectNameFormat, "una"], 
              CloudObject`Private`format]]; CloudObject`Private`userNew, 
           CloudObject`Private`res], CloudObject`Private`$tag]], 
      CloudObject`Private`processCloudObjectNameFormat[
        PatternTest[
         Pattern[CloudObject`Private`user, 
          Blank[]], CloudObject`Private`userProtocolQ], 
        Pattern[CloudObject`Private`format, 
         Blank[]]] := (Message[
         MessageName[CloudObjectNameFormat, "inv"], 
         CloudObject`Private`format]; StringDrop[CloudObject`Private`user, 
         StringLength["user:"]]), 
      CloudObject`Private`processCloudObjectNameFormat[
        Optional[
         Pattern[CloudObject`Private`user, 
          Blank[]], "~"], 
        Pattern[CloudObject`Private`format, 
         Alternatives[
         "UUID", "UserURLBase", "CloudUserID", "CloudUserUUID", "Literal", 
          Automatic]]] := Catch[
        With[{
         CloudObject`Private`res = 
          CloudObject`Private`userSpecificationFromNameFormat[
           CloudObject`Private`user, CloudObject`Private`format]}, 
         If[CloudObject`Private`res === None, Message[
            MessageName[CloudObjectNameFormat, "una"], 
            CloudObject`Private`format]; $UserURLBase, 
          CloudObject`Private`res]], CloudObject`Private`$tag], 
      CloudObject`Private`processCloudObjectNameFormat[
        Optional[
         Pattern[CloudObject`Private`user, 
          Blank[]], "~"], 
        Pattern[CloudObject`Private`format, 
         Blank[]]] := (Message[
         MessageName[CloudObjectNameFormat, "inv"], 
         CloudObject`Private`format]; $UserURLBase), 
      CloudObject`Private`userProtocolQ[
        Pattern[CloudObject`Private`user, 
         Blank[String]]] := StringMatchQ[CloudObject`Private`user, 
        StringExpression["user:", 
         BlankSequence[]]], CloudObject`Private`format[
        Pattern[CloudObject`Private`data, 
         Blank[]], 
        Pattern[CloudObject`Private`opts, 
         OptionsPattern[]]] := ReplaceAll[
        CloudObject`Private`iFormat[CloudObject`Private`data, 
         OptionValue["DepthLimit"], True, 
         OptionValue["KeyDensityThreshold"]], CloudObject`Private`iAtom -> 
        CloudObject`Private`atom[
          OptionValue["FailWithImages"]]], 
      Options[CloudObject`Private`format] = {
       "DepthLimit" :> CloudObject`Private`$DefaultDepth, 
        "KeyDensityThreshold" :> CloudObject`Private`$KeyDensityThreshold, 
        "Compact" -> True, "FailWithImages" :> 
        CloudObject`Private`$ReturnImage}, CloudObject`Private`iFormat[{}, 
        Pattern[CloudObject`Private`rest, 
         BlankNullSequence[]]] := CloudObject`Private`iFormat[{
         CloudObject`Private`iAtom[""]}, CloudObject`Private`rest], 
      CloudObject`Private`iFormat[
        Condition[
         PatternTest[
          Pattern[CloudObject`Private`data, 
           Blank[]], AssociationQ], 
         Not[
          AllTrue[CloudObject`Private`data, AssociationQ]]], 
        PatternTest[
         Pattern[CloudObject`Private`depth, 
          Blank[]], Positive], 
        Pattern[CloudObject`Private`col, 
         Blank[]], 
        Pattern[CloudObject`Private`threshold, 
         Blank[]]] := CloudObject`Private`iFormat[
        CloudObject`Private`addKeys[CloudObject`Private`depth][
        CloudObject`Private`data], 
        Replace[CloudObject`Private`depth, 1 -> 2], CloudObject`Private`col, 
        CloudObject`Private`threshold], Condition[
        CloudObject`Private`iFormat[
         Condition[
          Pattern[CloudObject`Private`data, 
           Alternatives[
            PatternTest[
             Blank[], ListQ], 
            PatternTest[
             Blank[], AssociationQ]]], 
          And[Length[CloudObject`Private`data] > 0, 
           AllTrue[CloudObject`Private`data, AssociationQ]]], 
         Pattern[CloudObject`Private`depth, 
          Blank[]], 
         Pattern[CloudObject`Private`col, 
          Blank[]], 
         Pattern[CloudObject`Private`threshold, 
          Blank[]]], CloudObject`Private`depth > 1] := If[
        CloudObject`Private`thresholdFailCheckQ[
        CloudObject`Private`data, CloudObject`Private`threshold], 
        With[{CloudObject`Private`newdata = Transpose[
            CloudObject`Private`keyUnion[CloudObject`Private`data, ""& ], 
            AllowedHeads -> All]}, 
         CloudObject`Private`iFormat[
          Prepend[
           Transpose[
            Values[CloudObject`Private`newdata], AllowedHeads -> All], 
           (If[
            AssociationQ[CloudObject`Private`data], "" -> #, #]& )[
            Map[CloudObject`Private`iAtom, 
             Keys[CloudObject`Private`newdata]]]], CloudObject`Private`depth, 
          CloudObject`Private`col, CloudObject`Private`threshold]], 
        CloudObject`Private`iFormat[
         Map[
          CloudObject`Private`addKeys[CloudObject`Private`depth - 1], 
          CloudObject`Private`data], 
         Replace[CloudObject`Private`depth, 2 -> 3], CloudObject`Private`col, 
         CloudObject`Private`threshold]], CloudObject`Private`iFormat[
        Pattern[CloudObject`Private`data, {
          BlankSequence[]}], 
        PatternTest[
         Pattern[CloudObject`Private`depth, 
          Blank[]], Positive], False, 
        Pattern[CloudObject`Private`threshold, 
         Blank[]]] := 
      With[{CloudObject`Private`newdata = 
         Map[CloudObject`Private`iFormat[#, CloudObject`Private`depth - 1, 
            True, CloudObject`Private`threshold]& , 
           CloudObject`Private`data]}, 
        With[{CloudObject`Private`max = Max[
            Map[Length, CloudObject`Private`newdata]]}, 
         Apply[Join[
           SlotSequence[1], 2]& , 
          Map[PadRight[#, CloudObject`Private`max, {
             ConstantArray[
              CloudObject`Private`iAtom[""], 
              Length[
               First[#]]]}]& , CloudObject`Private`newdata]]]], 
      CloudObject`Private`iFormat[
        Pattern[CloudObject`Private`data, 
         Blank[List]], 
        PatternTest[
         Pattern[CloudObject`Private`depth, 
          Blank[]], Positive], True, 
        Pattern[CloudObject`Private`threshold, 
         Blank[]]] := Transpose[
        CloudObject`Private`iFormat[
        CloudObject`Private`data, CloudObject`Private`depth, False, 
         CloudObject`Private`threshold]], CloudObject`Private`iFormat[
        Pattern[CloudObject`Private`data, 
         Blank[]], 
        Blank[], 
        Blank[], 
        Blank[]] := {{
         CloudObject`Private`iAtom[CloudObject`Private`data]}}, Condition[
        CloudObject`Private`iAtom[
         Pattern[CloudObject`Private`data, 
          Blank[]]], 
        Not[
         FreeQ[CloudObject`Private`data, CloudObject`Private`iAtom]]] := 
      CloudObject`Private`iAtom[
        ReplaceAll[
        CloudObject`Private`data, CloudObject`Private`iAtom -> Identity]], 
      Condition[
        CloudObject`Private`addKeys[
         Pattern[CloudObject`Private`depth, 
          Blank[]]][
         PatternTest[
          Pattern[CloudObject`Private`data, 
           Blank[]], AssociationQ]], CloudObject`Private`depth > 1] := 
      MapThread[Which[
         ListQ[#], 
         Prepend[
          SlotSequence[1]], 
         AssociationQ[#], 
         Prepend[#, "" -> #2], True, {#2, #}]& , {
         Values[CloudObject`Private`data], 
         Map[CloudObject`Private`iAtom, 
          Keys[CloudObject`Private`data]]}], CloudObject`Private`addKeys[1][
        PatternTest[
         Pattern[CloudObject`Private`data, 
          Blank[]], AssociationQ]] := Transpose[
        Map[CloudObject`Private`iAtom, {
          Keys[CloudObject`Private`data], 
          Values[CloudObject`Private`data]}, {2}]], 
      CloudObject`Private`thresholdFailCheckQ[
        Pattern[CloudObject`Private`data, 
         Blank[]], None] := True, CloudObject`Private`thresholdFailCheckQ[
        Pattern[CloudObject`Private`data, 
         Blank[]], 
        Pattern[CloudObject`Private`threshold, 
         Blank[]]] := 
      With[{CloudObject`Private`keys = Map[Keys, CloudObject`Private`data]}, 
        N[Mean[
            Map[Length, CloudObject`Private`keys]]/Length[
           DeleteDuplicates[
            Apply[Join, CloudObject`Private`keys]]]] > 
        CloudObject`Private`threshold], CloudObject`Private`keyUnion[
        Pattern[CloudObject`Private`l, {
          PatternTest[
           BlankSequence[], AssociationQ]}], 
        Pattern[CloudObject`Private`rest, 
         BlankNullSequence[]]] := 
      KeyUnion[CloudObject`Private`l, CloudObject`Private`rest], 
      CloudObject`Private`keyUnion[
        Condition[
         PatternTest[
          Pattern[CloudObject`Private`ass, 
           Blank[]], AssociationQ], 
         AllTrue[CloudObject`Private`ass, AssociationQ]], 
        Pattern[CloudObject`Private`rest, 
         BlankNullSequence[]]] := AssociationThread[
        Keys[CloudObject`Private`ass], 
        KeyUnion[
         Values[CloudObject`Private`ass], CloudObject`Private`rest]], 
      CloudObject`Private`atom[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[String]], StringQ]] := If[
        CloudObject`Private`tooLongQ[CloudObject`Private`x], 
        CloudObject`Private`exprBehaviour[CloudObject`Private`imgq][
        CloudObject`Private`x], 
        Association["data" -> CloudObject`Private`x, "type" -> "String"]], 
      CloudObject`Private`atom[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[Integer]], Developer`MachineIntegerQ]] := 
      Association[
       "data" -> ToString[CloudObject`Private`x], "type" -> "Integer"], 
      CloudObject`Private`atom[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[Integer]], NumericQ]] := Association["data" -> If[
          CloudObject`Private`tooLongQ[CloudObject`Private`x], 
          CloudObject`Private`excelExponentForm[
           N[CloudObject`Private`x]], 
          ToString[CloudObject`Private`x]], "type" -> "Integer"], 
      CloudObject`Private`atom[
        Blank[]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[Real]], MachineNumberQ]] := 
      Association[
       "data" -> CloudObject`Private`excelExponentForm[CloudObject`Private`x],
         "type" -> "Real"], CloudObject`Private`atom[
        Blank[]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[Real]], NumericQ]] := 
      Association[
       "data" -> CloudObject`Private`excelExponentForm[CloudObject`Private`x],
         "type" -> "Real"], CloudObject`Private`atom[
        Blank[]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[Rational]], NumericQ]] := 
      Association["data" -> CloudObject`Private`excelExponentForm[
          N[CloudObject`Private`x]], "type" -> "Real"], 
      CloudObject`Private`atom[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[Symbol]], NumericQ]] := 
      Association["data" -> CloudObject`Private`excelExponentForm[
          N[CloudObject`Private`x]], "type" -> "Real"], 
      CloudObject`Private`atom[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[]], NumericQ]] := 
      Association["data" -> CloudObject`Private`excelExponentForm[
          N[CloudObject`Private`x]], "type" -> "Real"], 
      CloudObject`Private`atom[
        Blank[]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[DateObject]], DateObjectQ]] := 
      Association[
       "data" -> CloudObject`Private`dateObjectToExcelDate[
         CloudObject`Private`x], "type" -> "ExcelDate"], 
      CloudObject`Private`atom[
        Blank[]][
        PatternTest[
         Pattern[CloudObject`Private`x, 
          Blank[]], BooleanQ]] := Association["data" -> ToUpperCase[
          ToString[CloudObject`Private`x]], "type" -> "Boolean"], 
      CloudObject`Private`atom[
        Pattern[CloudObject`Private`x, 
         Blank[]]][
        HoldPattern[
         Quantity[
          Pattern[CloudObject`Private`magnitude, 
           Blank[]], 
          Pattern[CloudObject`Private`unit, 
           Blank[]]]]] := 
      CloudObject`Private`atom[CloudObject`Private`x][
       CloudObject`Private`magnitude], CloudObject`Private`atom[
        Blank[]][
        Pattern[CloudObject`Private`x, 
         Alternatives[
          Blank[Graphics3D], 
          Blank[Graphics], 
          Blank[Image], 
          Blank[GeoGraphics]]]] := 
      Association[
       "data" -> CloudObject`Private`exportToPNGBase64[CloudObject`Private`x],
         "type" -> ToString[
          Head[CloudObject`Private`x]]], CloudObject`Private`atom[
        Blank[]][
        Pattern[CloudObject`Private`fullExpr, 
         Legended[
          Pattern[CloudObject`Private`innerExpr, 
           Alternatives[
            Blank[Graphics3D], 
            Blank[Graphics], 
            Blank[Image], 
            Blank[GeoGraphics]]], 
          BlankNullSequence[]]]] := 
      Association[
       "data" -> CloudObject`Private`exportToPNGBase64[
         CloudObject`Private`fullExpr], "type" -> ToString[
          Head[CloudObject`Private`innerExpr]]], CloudObject`Private`atom[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        Pattern[CloudObject`Private`x, 
         Blank[Symbol]]] := CloudObject`Private`atom[CloudObject`Private`imgq][
        SymbolName[CloudObject`Private`x]], CloudObject`Private`atom[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        Pattern[CloudObject`Private`x, 
         Blank[]]] := 
      CloudObject`Private`exprBehaviour[CloudObject`Private`imgq][
       CloudObject`Private`x], CloudObject`Private`tooLongQ[
        Pattern[CloudObject`Private`str, 
         Blank[String]]] := 
      If[StringLength[CloudObject`Private`str] > 
        CloudObject`Private`$ExcelCharacterLimit, True, False], 
      CloudObject`Private`tooLongQ[
        Pattern[CloudObject`Private`int, 
         Blank[Integer]]] := 
      If[IntegerLength[CloudObject`Private`int] > 
        CloudObject`Private`$NumberSizeLimit, True, False], 
      CloudObject`Private`$ExcelCharacterLimit = 32767, 
      CloudObject`Private`$NumberSizeLimit = 308, 
      CloudObject`Private`exprBehaviour[
        Pattern[CloudObject`Private`imgq, 
         Blank[]]][
        Pattern[CloudObject`Private`x, 
         Blank[]]] := If[CloudObject`Private`imgq, 
        Association["data" -> CloudObject`Private`exportToPNGBase64[
           CloudObject`Private`limitOutput[CloudObject`Private`x]], "type" -> 
         "Expression"], 
        Association[
        "data" -> CloudObject`Private`$ExcelError, "type" -> "String"]], 
      CloudObject`Private`exportToPNGBase64[
        Pattern[CloudObject`Private`img, 
         Blank[]]] := Developer`EncodeBase64[
        ExportString[CloudObject`Private`img, "PNG"]], 
      CloudObject`Private`limitOutput[
        Pattern[CloudObject`Private`x, 
         Blank[String]]] := OutputSizeLimit`Short[CloudObject`Private`x], 
      CloudObject`Private`limitOutput[
        Pattern[CloudObject`Private`x, 
         Blank[]]] := With[{CloudObject`Private`fmt = OptionValue[
           Options[$Output], FormatType], CloudObject`Private`outputsizelimit = 
         If[
           Or[$OutputSizeLimit === Infinity, 
            NumericQ[$OutputSizeLimit]], $OutputSizeLimit, 2^20]}, 
        If[
         Or[
          Not[
           MemberQ[$BoxForms, CloudObject`Private`fmt]], 
          MatchQ[
           HoldComplete[CloudObject`Private`x], 
           Blank[][OutputSizeLimit`Dump`$unlimitedTextPattern]], 
          MatchQ[
           HoldComplete[CloudObject`Private`x], 
           Blank[][OutputSizeLimit`Dump`$unlimitedBoxPattern]]], 
         Unevaluated[CloudObject`Private`x], 
         With[{
          CloudObject`Private`boxes = 
           Block[{$RecursionLimit = Typeset`$RecursionLimit}, 
             MakeBoxes[CloudObject`Private`x, CloudObject`Private`fmt]]}, 
          OutputSizeLimit`Dump`loadSizeCountRules[]; If[
            TrueQ[
             BoxForm`SizeCount[
             CloudObject`Private`boxes, CloudObject`Private`outputsizelimit]], 
            BoxForm`AbsoluteRawBoxes[CloudObject`Private`boxes], 
            OutputSizeLimit`Short[CloudObject`Private`x]]], 
         Unevaluated[CloudObject`Private`x]]], $Output = {
        OutputStream["stdout", 1]}, 
      Attributes[$OutputSizeLimit] = {ReadProtected}, 
      Attributes[$BoxForms] = {ReadProtected}, 
      OutputSizeLimit`Dump`$unlimitedTextPattern = Alternatives[
        Blank[CForm], 
        Blank[FortranForm], 
        Blank[InputForm], 
        Blank[MathMLForm], 
        Blank[OutputForm], 
        Blank[TeXForm], 
        Blank[TextForm]], OutputSizeLimit`Dump`$unlimitedBoxPattern := 
      Apply[Alternatives, 
        Map[Blank, 
         Join[$BoxForms, {TableView}]]], $RecursionLimit = 1024, 
      Attributes[Typeset`$RecursionLimit] = {ReadProtected}, 
      Attributes[MakeBoxes] = {HoldAllComplete}, MakeBoxes[
        Pattern[CloudObject`Private`v, 
         CloudObject`Private`Var[
          PatternTest[
           Blank[], AssociationQ]]], 
        Pattern[CloudObject`Private`fmt, 
         Blank[]]] := 
      With[{CloudObject`Private`name = CloudObject`Private`v["name"], 
         CloudObject`Private`val = CloudObject`Private`v["get"][]}, 
        MakeBoxes[
         Panel[
          "Var"[
           Row[{CloudObject`Private`name, ": ", CloudObject`Private`val}]], 
          Background -> Lighter[Gray, 0.9]], CloudObject`Private`fmt]], 
      CloudObject`Private`Var[
        PatternTest[
         Pattern[CloudObject`Private`obj, 
          Blank[]], AssociationQ]][
        Pattern[CloudObject`Private`key, 
         Blank[]]] := CloudObject`Private`obj[CloudObject`Private`key], 
      OutputSizeLimit`Dump`loadSizeCountRules[] = Null, 
      UpSetDelayed[
       MakeBoxes[
        BoxForm`AbsoluteRawBoxes[
         Pattern[BoxForm`boxes, 
          Blank[]]], 
        Pattern[BoxForm`fmt, 
         Blank[]]], BoxForm`boxes], CloudObject`Private`$ExcelError = "#N/A", 
      CloudObject`Private`excelExponentForm[
        PatternTest[
         Pattern[CloudObject`Private`number, 
          Blank[]], CloudObject`Private`exponentCorrectionCheck]] := 
      ToString[
        NumberForm[
        CloudObject`Private`number, CloudObject`Private`$ExcelPrecision, 
         NumberFormat -> (Row[{#, "E", #3}]& )]], 
      CloudObject`Private`excelExponentForm[
        Pattern[CloudObject`Private`number, 
         Blank[]]] := ToString[
        NumberForm[
        CloudObject`Private`number, CloudObject`Private`$ExcelPrecision]], 
      CloudObject`Private`exponentCorrectionCheck[
        Pattern[CloudObject`Private`number, 
         Blank[]]] := 
      Or[CloudObject`Private`number < -1000000, CloudObject`Private`number > 
        1000000, -1.*^-6 < CloudObject`Private`number < 1.*^-6], 
      CloudObject`Private`$ExcelPrecision = 16, 
      Attributes[CloudObject`Private`dateObjectToExcelDate] = {Listable}, 
      CloudObject`Private`dateObjectToExcelDate[
        Pattern[CloudObject`Private`date, 
         Blank[]]] := QuantityMagnitude[
         UnitConvert[
          Quantity[
           AbsoluteTime[CloudObject`Private`date], "Seconds"], "Days"]] + 2, 
      CloudObject`Private`$DefaultDepth = 2, 
      CloudObject`Private`$KeyDensityThreshold = 0.75, 
      CloudObject`Private`$ReturnImage = False, 
      CloudObject`Private`userSpecificationFromNameFormat[
        Pattern[CloudObject`Private`user, 
         Blank[]], 
        Alternatives[Automatic, "Literal", "UUID"]] := 
      CloudObject`Private`userSpecificationFromNameFormat[
       CloudObject`Private`user, 
        Replace[$CloudObjectNameFormat, Alternatives[Automatic, "UUID"] -> 
         "UserURLBase"]], 
      CloudObject`Private`userSpecificationFromNameFormat[
        Pattern[CloudObject`Private`user, 
         Blank[]], 
        Pattern[CloudObject`Private`format, 
         Alternatives["UserURLBase", "CloudUserID", "CloudUserUUID"]]] := 
      CloudObject`Private`nameFormatOptionToValue[
       CloudObject`Private`user, CloudObject`Private`format], 
      CloudObject`Private`userSpecificationFromNameFormat[
        Pattern[CloudObject`Private`user, 
         Blank[]], 
        Pattern[CloudObject`Private`format, 
         Blank[]]] := None, 
      Attributes[$CloudObjectNameFormat] = {ReadProtected}, 
      CloudObject`Private`nameFormatOptionToValue[
        Pattern[CloudObject`Private`format, 
         Blank[]]] := (If[$CloudUserID === None, CloudConnect[]; If[
           Not[
            TrueQ[$CloudConnected]], Message[
             MessageName[CloudObject, "notauth"]]; 
           Throw[$Failed, CloudObject`Private`$tag]]]; 
       Switch[CloudObject`Private`format, "UserURLBase", 
         If[
          StringQ[$UserURLBase], $UserURLBase, 
          If[$CloudUserUUID === None, None, 
           StringJoin[CloudObject`Private`userUUIDPrefix, $CloudUserUUID]]], 
         "CloudUserID", $CloudUserID, "CloudUserUUID", 
         If[$CloudUserUUID === None, None, 
          StringJoin[CloudObject`Private`userUUIDPrefix, $CloudUserUUID]], 
         Blank[], None]), CloudObject`Private`nameFormatOptionToValue["~", 
        Pattern[CloudObject`Private`format, 
         Blank[]]] := 
      CloudObject`Private`nameFormatOptionToValue[CloudObject`Private`format],
       Condition[
        CloudObject`Private`nameFormatOptionToValue[
         Pattern[CloudObject`Private`usr, 
          Blank[]], 
         Pattern[CloudObject`Private`format, 
          Blank[]]], 
        CloudObject`Private`isOwner[CloudObject`Private`usr]] := 
      CloudObject`Private`nameFormatOptionToValue[
       "~", CloudObject`Private`format], 
      CloudObject`Private`nameFormatOptionToValue[
        Pattern[CloudObject`Private`usr, 
         Blank[]], "Literal"] := CloudObject`Private`usr, 
      CloudObject`Private`nameFormatOptionToValue[
        Pattern[CloudObject`Private`usr, 
         Blank[]], 
        Pattern[CloudObject`Private`format, 
         Blank[]]] := 
      Module[{CloudObject`Private`json, CloudObject`Private`importJSON, 
         CloudObject`Private`userInfo, CloudObject`Private`res}, 
        If[
         And[
          StringMatchQ[CloudObject`Private`usr, 
           StringExpression[
           CloudObject`Private`userUUIDPrefix, 
            CloudObject`Private`$uuidPattern]], CloudObject`Private`format === 
          "CloudUserUUID"], CloudObject`Private`usr, 
         CloudObject`Private`json = Replace[
            
            CloudObject`Private`execute[$CloudBase, "GET", {"users"}, 
             CloudObject`Private`Parameters -> {
              "id" -> CloudObject`Private`usr}], {{
               Blank[], 
               Pattern[CloudObject`Private`bytes, 
                Blank[List]]} :> FromCharacterCode[CloudObject`Private`bytes],
              CloudObject`Private`HTTPError[404, 
               BlankNullSequence[]] :> (Message[
                MessageName[CloudObject, "invusr"], 
                CloudObject`Private`usr]; $Failed), 
             Pattern[CloudObject`Private`other, 
               Blank[]] :> (
              CloudObject`Private`checkError[
               CloudObject`Private`other]; $Failed)}]; 
         If[CloudObject`Private`json === $Failed, None, 
           CloudObject`Private`importJSON = 
            CloudObject`Private`handleUsersJSONObject[
              CloudObject`Private`importFromJSON[CloudObject`Private`json]]; 
           If[
             MatchQ[CloudObject`Private`importJSON, {
               BlankSequence[List]}], 
             CloudObject`Private`userInfo = 
              Flatten[CloudObject`Private`importJSON]; 
             CloudObject`Private`res = Replace[
                Lookup[CloudObject`Private`userInfo, 
                 Replace[
                 CloudObject`Private`format, {
                  "UserURLBase" -> "userBaseUrl", "CloudUserID" -> "email", 
                   "CloudUserUUID" -> "uuid"}]], Missing[
                  Pattern[CloudObject`Private`x, 
                   BlankNullSequence[]]] :> None], None]; If[
             And[
              StringQ[CloudObject`Private`res], CloudObject`Private`format === 
              "CloudUserUUID"], 
             StringJoin[
             CloudObject`Private`userUUIDPrefix, CloudObject`Private`res], 
             CloudObject`Private`res]]]], CloudObject`Private`$tag = 
      "CloudObjectCatchThrowTag", CloudObject`Private`userUUIDPrefix = 
      "user-", CloudObject`Private`isOwner[
        Pattern[CloudObject`Private`user, 
         Blank[String]]] := 
      Or[CloudObject`Private`user === $CloudUserID, 
        CloudObject`Private`user === $UserURLBase, 
        StringReplace[
         CloudObject`Private`user, 
          StringExpression[CloudObject`Private`userUUIDPrefix, 
            Pattern[CloudObject`Private`uuid, 
             Blank[]]] :> CloudObject`Private`uuid] === $CloudUserUUID], 
      CloudObject`Private`isOwner[
        Pattern[CloudObject`Private`user, 
         Blank[]]] := False, CloudObject`Private`$uuidPattern = 
      StringExpression[
        Repeated[HexadecimalCharacter, {8}], "-", 
        Repeated[HexadecimalCharacter, {4}], "-4", 
        Repeated[HexadecimalCharacter, {3}], "-", 
        Repeated[HexadecimalCharacter, {4}], "-", 
        Repeated[HexadecimalCharacter, {12}]], CloudObject`Private`execute[
        Pattern[CloudObject`Private`cloud, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]], 
        Optional[
         Pattern[CloudObject`Private`path, 
          Blank[List]], {}], 
        Pattern[CloudObject`Private`opts, 
         OptionsPattern[]]] := If[
        And[
         TrueQ[$CloudEvaluation], 
         CloudObject`Private`cloud === $EvaluationCloudBase], 
        CloudObject`Private`executeInCloud[
        CloudObject`Private`cloud, CloudObject`Private`method, 
         CloudObject`Private`path, CloudObject`Private`opts], 
        CloudObject`Private`executeRemotely[
        CloudObject`Private`cloud, CloudObject`Private`method, 
         CloudObject`Private`path, CloudObject`Private`opts]], 
      CloudObject`Private`execute[
        Pattern[CloudObject`Private`obj, 
         Blank[CloudObject]], 
        Optional[
         Pattern[CloudObject`Private`method, 
          Alternatives[
           Blank[String], Automatic]], "GET"], 
        Optional[
         Pattern[CloudObject`Private`api, 
          Blank[String]], "files"], 
        Optional[
         Pattern[CloudObject`Private`subpath, 
          Blank[List]], {}], 
        Pattern[CloudObject`Private`options, 
         OptionsPattern[]]] := 
      Module[{CloudObject`Private`cloud, CloudObject`Private`uuid, 
         CloudObject`Private`path, CloudObject`Private`methodToUse, 
         CloudObject`Private`parameters, CloudObject`Private`newOptions, 
         CloudObject`Private`optionBody, 
         CloudObject`Private`bodyIsCloudObject}, 
        If[
        OptionValue[CloudObject`Private`UseUUID] === 
         True, {CloudObject`Private`cloud, CloudObject`Private`uuid} = 
          CloudObject`Private`getCloudAndUUID[CloudObject`Private`obj]; If[
           Not[
            CloudObject`UUIDQ[CloudObject`Private`uuid]], 
           Return[
            CloudObject`Private`handleBadObjectUUIDForExecute[
            CloudObject`Private`uuid, CloudObject`Private`obj]]]; 
         CloudObject`Private`log[
          "Executing on UUID `1`", CloudObject`Private`uuid]; 
         CloudObject`Private`execute[
          CloudObject`Private`cloud, CloudObject`Private`method, {
           CloudObject`Private`api, CloudObject`Private`uuid, 
            CloudObject`Private`subpath}, CloudObject`Private`options], {
           CloudObject`Private`cloud, CloudObject`Private`uuid, 
            CloudObject`Private`path} = 
          CloudObject`Private`getCloudAndUUIDOrPath[CloudObject`Private`obj]; 
         If[CloudObject`Private`uuid === $Failed, 
           Return[{$Failed, $Failed}]]; 
         If[CloudObject`Private`method === Automatic, 
           If[
           CloudObject`Private`uuid === None, CloudObject`Private`methodToUse = 
            "POST", CloudObject`Private`methodToUse = "PUT"]]; 
         CloudObject`Private`parameters = 
          OptionValue[CloudObject`Private`Parameters]; 
         CloudObject`Private`optionBody = 
          OptionValue[CloudObject`Private`Body]; 
         CloudObject`Private`bodyIsCloudObject = 
          Head[CloudObject`Private`optionBody] === CloudObject; 
         If[CloudObject`Private`bodyIsCloudObject, 
           
           Module[{CloudObject`Private`srccloud, 
             CloudObject`Private`srcuuid}, {
              CloudObject`Private`srccloud, CloudObject`Private`srcuuid} = 
             CloudObject`Private`getCloudAndUUID[
              CloudObject`Private`optionBody]; If[
              Not[
               CloudObject`UUIDQ[CloudObject`Private`srcuuid]], 
              Return[
               CloudObject`Private`handleBadObjectUUIDForExecute[
               CloudObject`Private`srcuuid, CloudObject`Private`optionBody]]]; 
            CloudObject`Private`parameters = 
             Join[CloudObject`Private`parameters, {
                If[
                 TrueQ[CloudObject`Private`getCloudVersionNumber[] > 1.56], 
                 "copyFrom" -> CloudObject`Private`srcuuid, "copyContentFrom" -> 
                 CloudObject`Private`srcuuid]}]; Null]]; 
         CloudObject`Private`newOptions = Join[
            If[
            CloudObject`Private`bodyIsCloudObject, {
             CloudObject`Private`Body -> {}}, {}], {
            CloudObject`Private`options}]; 
         If[CloudObject`Private`uuid === None, 
           CloudObject`Private`execute[
           CloudObject`Private`cloud, CloudObject`Private`methodToUse, {
            CloudObject`Private`api, CloudObject`Private`subpath}, 
            CloudObject`Private`Parameters -> 
            Join[CloudObject`Private`parameters, {
              "path" -> CloudObject`JoinURL[CloudObject`Private`path]}], 
            CloudObject`Private`newOptions], 
           CloudObject`Private`execute[
           CloudObject`Private`cloud, CloudObject`Private`methodToUse, {
            CloudObject`Private`api, CloudObject`Private`uuid, 
             CloudObject`Private`subpath}, CloudObject`Private`Parameters -> 
            CloudObject`Private`parameters, 
            CloudObject`Private`newOptions]]]], CloudObject`Private`execute[
        Pattern[CloudObject`Private`group, 
         Blank[PermissionsGroup]], 
        Pattern[CloudObject`Private`rest, 
         BlankNullSequence[]]] := CloudObject`Private`execute[
        Apply[CloudObject, CloudObject`Private`group], 
        CloudObject`Private`rest], 
      Options[CloudObject`Private`execute] = {
       CloudObject`Private`Parameters -> {}, CloudObject`Private`Body -> {}, 
        CloudObject`Private`Type -> "text/plain", CloudObject`Private`UseUUID -> 
        True, Asynchronous -> False, "ResponseFormat" -> "ByteList"}, 
      Attributes[$EvaluationCloudBase] = {ReadProtected}, 
      CloudObject`Private`executeInCloud[
        Pattern[CloudObject`Private`cloud, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]], 
        Optional[
         Pattern[CloudObject`Private`path, 
          Blank[List]], {}], 
        OptionsPattern[]] := 
      Module[{CloudObject`Private`parameters, CloudObject`Private`mimetype = 
         OptionValue[CloudObject`Private`Type], CloudObject`Private`body = 
         OptionValue[CloudObject`Private`Body], 
         CloudObject`Private`bodyString, CloudObject`Private`responseFormat = 
         OptionValue["ResponseFormat"]}, 
        CloudObject`Private`parameters = 
         OptionValue[CloudObject`Private`Parameters]; 
        CloudObject`Private`log[
         "Calling server `1` `2` with MIME type `3`, parameters `4`", 
          CloudObject`Private`method, 
          CloudObject`JoinURL[CloudObject`Private`path], 
          CloudObject`Private`mimetype, 
          ToString[CloudObject`Private`parameters, InputForm], 
          CloudObject`Private`DebugLevel -> 2]; 
        If[CloudObject`Private`body =!= {}, 
          CloudObject`Private`log[
           "Content: `1`", CloudObject`Private`body, 
            CloudObject`Private`DebugLevel -> 2]; Null]; 
        CloudObject`Private`bodyString = 
         Switch[CloudObject`Private`body, Blank[List] :> 
           FromCharacterCode[CloudObject`Private`body], PatternTest[
             Blank[], ByteArrayQ] :> 
           ByteArrayToString[CloudObject`Private`body, "ISO8859-1"], 
           Blank[], CloudObject`Private`body]; 
        CloudObject`Private`$lastExecuteResult = 
         CloudSystem`Private`writeCallPacketService[
           CloudSystem`CloudObject`DoCloudOperation[
           CloudObject`Private`method, CloudObject`Private`path, 
            CloudObject`Private`parameters, CloudObject`Private`mimetype, 
            CloudObject`Private`bodyString]]; 
        CloudObject`Private`log["Call packet result: `1`", 
          ToString[CloudObject`Private`$lastExecuteResult, InputForm], 
          CloudObject`Private`DebugLevel -> 2]; 
        Replace[CloudObject`Private`$lastExecuteResult, {{
             Pattern[CloudObject`Private`type, 
              Blank[]], 
             File[
              Pattern[CloudObject`Private`resultFile, 
               Blank[String]]]} :> {
             CloudObject`Private`contentTypeCheck[CloudObject`Private`type], 
             File[CloudObject`Private`resultFile]}, {
             Pattern[CloudObject`Private`type, 
              Blank[]], 
             Pattern[CloudObject`Private`result, 
              Blank[String]]} :> {
             CloudObject`Private`contentTypeCheck[CloudObject`Private`type], 
             If[
             CloudObject`Private`responseFormat === "ByteString", 
              CloudObject`Private`result, 
              ToCharacterCode[CloudObject`Private`result]]}, {
             Pattern[CloudObject`Private`type, 
              Blank[]], 
             Pattern[CloudObject`Private`result, 
              Blank[List]]} :> {
             CloudObject`Private`contentTypeCheck[CloudObject`Private`type], 
             CloudObject`Private`result}, CloudObject`Private`HTTPError[
             PatternTest[
              Pattern[CloudObject`Private`status, 
               Blank[Integer]], Positive], 
             Pattern[CloudObject`Private`content, 
              Blank[]], 
             Pattern[CloudObject`Private`type, 
              Blank[]]] :> 
           CloudObject`Private`HTTPError[CloudObject`Private`status, 
             CloudObject`Private`preprocessErrorContent[
             CloudObject`Private`content, CloudObject`Private`type], 
             CloudObject`Private`type], CloudObject`Private`HTTPError[
             PatternTest[
              Pattern[CloudObject`Private`status, 
               Blank[Integer]], Positive], 
             Pattern[CloudObject`Private`content, 
              Blank[]]] :> 
           CloudObject`Private`HTTPError[CloudObject`Private`status, 
             CloudObject`Private`preprocessContent[
             CloudObject`Private`content]], CloudObject`Private`HTTPAccepted[
             PatternTest[
              Pattern[CloudObject`Private`status, 
               Blank[Integer]], Positive], 
             Pattern[CloudObject`Private`cont, 
              Blank[]], 
             Pattern[CloudObject`Private`type, 
              Blank[]]] :> {
             CloudObject`Private`contentTypeCheck[CloudObject`Private`type], 
             ToCharacterCode[CloudObject`Private`cont]}, 
           Pattern[CloudObject`Private`err, 
             CloudObject`Private`HTTPError[
              PatternTest[
               Blank[Integer], Positive]]] :> CloudObject`Private`err, 
           Blank[] :> CloudObject`Private`HTTPError[500]}]], 
      Options[CloudObject`Private`executeInCloud] = {
       CloudObject`Private`Parameters -> {}, CloudObject`Private`Body -> {}, 
        CloudObject`Private`Type -> "text/plain", CloudObject`Private`UseUUID -> 
        True, Asynchronous -> False, "ResponseFormat" -> "ByteList"}, 
      CloudObject`Private`contentTypeCheck[
        Pattern[CloudObject`Private`type, 
         Blank[]]] := Replace[CloudObject`Private`type, Except[
          Blank[String]] -> "text/plain"], 
      CloudObject`Private`preprocessErrorContent[
        Pattern[CloudObject`Private`content, 
         Blank[]], "application/json"] := 
      Module[{CloudObject`Private`data}, 
        CloudObject`Private`data = CloudObject`Private`importFromJSON[
           CloudObject`Private`preprocessContent[
           CloudObject`Private`content]]; 
        CloudObject`Private`log[
         "Error content: `1`", CloudObject`Private`data, 
          CloudObject`Private`DebugLevel -> 2]; CloudObject`Private`data], 
      CloudObject`Private`preprocessErrorContent[
        Pattern[CloudObject`Private`content, 
         Blank[]], 
        Pattern[CloudObject`Private`type, 
         Blank[]]] := 
      CloudObject`Private`preprocessContent[CloudObject`Private`content], 
      CloudObject`Private`importFromJSON = Developer`FromJSON, 
      Developer`FromJSON[
        Pattern[System`Private`json, 
         Blank[String]], 
        Pattern[System`Private`opts, 
         OptionsPattern[]]] := 
      Developer`ReadRawJSONString[
       System`Private`json, "JSONObjectAsList" -> True, "IssueMessagesAs" -> 
        Developer`FromJSON, System`Private`opts], 
      Options[Developer`FromJSON] = {}, 
      CloudObject`Private`preprocessContent[
        Pattern[CloudObject`Private`content, 
         Blank[List]]] := 
      FromCharacterCode[CloudObject`Private`content, "UTF-8"], 
      CloudObject`Private`preprocessContent[
        Pattern[CloudObject`Private`content, 
         Blank[]]] := CloudObject`Private`content, 
      CloudObject`Private`executeRemotely[
        Pattern[CloudObject`Private`cloud, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]], 
        Optional[
         Pattern[CloudObject`Private`path, 
          Blank[List]], {}], 
        OptionsPattern[]] := 
      Module[{CloudObject`Private`url, CloudObject`Private`bodyValue = 
         OptionValue[CloudObject`Private`Body]}, 
        CloudObject`Private`url = StringJoin[
           
           CloudObject`JoinURL[{
            CloudObject`Private`cloud, CloudObject`Private`path}], 
           CloudObject`JoinURLSearch[
            OptionValue[CloudObject`Private`Parameters]]]; 
        CloudObject`Private`callServer[
         CloudObject`Private`cloud, CloudObject`Private`url, 
          OptionValue[CloudObject`Private`Type], CloudObject`Private`method, 
          CloudObject`Private`bodyValue, 
          OptionValue[Asynchronous]]], 
      Options[CloudObject`Private`executeRemotely] = {
       CloudObject`Private`Parameters -> {}, CloudObject`Private`Body -> {}, 
        CloudObject`Private`Type -> "text/plain", CloudObject`Private`UseUUID -> 
        True, Asynchronous -> False, "ResponseFormat" -> "ByteList"}, 
      CloudObject`JoinURLSearch[
        Pattern[CloudObject`Private`values, 
         Blank[]]] := If[Length[CloudObject`Private`values] > 0, 
        StringJoin["?", 
         URLQueryEncode[
          Flatten[{CloudObject`Private`values}]]], ""], 
      CloudObject`Private`callServer[
        Pattern[CloudObject`Private`cloud, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[]], 
        Optional[
         Pattern[CloudObject`Private`mimetype, 
          Blank[]], "text/plain"], 
        Optional[
         Pattern[CloudObject`Private`httpVerb, 
          Blank[]], "GET"], 
        Optional[
         Pattern[CloudObject`Private`body, 
          Blank[]], ""], 
        Optional[
         Pattern[CloudObject`Private`async, 
          Blank[]], False]] := 
      Module[{
        CloudObject`Private`response, CloudObject`Private`status, 
         CloudObject`Private`headers, CloudObject`Private`content, 
         CloudObject`Private`callFunction, CloudObject`Private`finalURL, 
         CloudObject`Private`contentType, CloudObject`Private`localBody = 
         Replace[CloudObject`Private`body, {} -> ""]}, 
        CloudObject`Private`log[
         "Calling remote server: `1` `2` with MIME type `3`", 
          CloudObject`Private`httpVerb, CloudObject`Private`url, 
          CloudObject`Private`mimetype]; 
        CloudObject`Private`log["Decoded URL: `1`", 
          URLDecode[CloudObject`Private`url], CloudObject`Private`DebugLevel -> 
          2]; CloudObject`Private`log["Request content: `1`", 
          CloudObject`Private`contentDisplay[CloudObject`Private`localBody], 
          CloudObject`Private`DebugLevel -> 2]; 
        CloudObject`Private`finalURL = CloudObject`Private`url; 
        CloudObject`Private`callFunction = 
         If[CloudObject`Private`async, CloudObject`Private`fetchURLAsync, 
           CloudObject`Private`fetchURL]; 
        CloudObject`Private`response = 
         CloudObject`Private`callFunction[
          CloudObject`Private`cloud, CloudObject`Private`finalURL, {
           "StatusCode", "Headers", "ContentData"}, "Method" -> 
           CloudObject`Private`httpVerb, 
           "Headers" -> {
            "Content-Type" -> CloudObject`Private`mimetype, "Accept" -> 
             "application/vnd.wolfram.v1"}, "Body" -> 
           CloudObject`Private`localBody, "VerifyPeer" -> 
           CloudObject`Private`verifyPeerQ[CloudObject`Private`cloud], 
           "DisplayProxyDialog" -> False]; If[
          MatchQ[CloudObject`Private`response, {
            Blank[], 
            Blank[], 
            Blank[]}], {
           CloudObject`Private`status, CloudObject`Private`headers, 
            CloudObject`Private`content} = CloudObject`Private`response, 
          If[
           MatchQ[CloudObject`Private`response, 
            Blank[CloudObject`Private`HTTPError]], 
           Return[CloudObject`Private`response], 
           Return[
            CloudObject`Private`HTTPError[404]]]]; 
        CloudObject`Private`log[
         "Response status: `1`", CloudObject`Private`status]; 
        If[CloudObject`Private`headers =!= {}, 
          CloudObject`Private`log[
           "Response headers: `1`", CloudObject`Private`headers, 
            CloudObject`Private`DebugLevel -> 2]; Null]; 
        CloudObject`Private`log["Response content: `1`", 
          CloudObject`Private`contentDisplay[CloudObject`Private`content], 
          CloudObject`Private`DebugLevel -> 2]; 
        CloudObject`Private`contentType = 
         CloudObject`Private`getHeader[
          CloudObject`Private`headers, "content-type"]; If[
          Not[
           And[
           CloudObject`Private`status >= 200, CloudObject`Private`status < 
            300]], CloudObject`Private`content = 
           CloudObject`Private`preprocessErrorContent[
            CloudObject`Private`content, CloudObject`Private`contentType]; 
          Return[
            CloudObject`Private`HTTPError[
            CloudObject`Private`status, CloudObject`Private`content, 
             CloudObject`Private`contentType]]]; {
         CloudObject`Private`contentType, CloudObject`Private`content}], 
      CloudObject`Private`contentDisplay[
        Pattern[CloudObject`Private`list, {
          RepeatedNull[
           Blank[Integer]]}]] := FromCharacterCode[CloudObject`Private`list], 
      CloudObject`Private`contentDisplay[
        Pattern[CloudObject`Private`value, 
         Blank[String]]] := CloudObject`Private`value, 
      CloudObject`Private`contentDisplay[
        Pattern[CloudObject`Private`expr, 
         Blank[]]] := ToString[CloudObject`Private`expr, InputForm], 
      CloudObject`Private`fetchURLAsync[
        Pattern[CloudObject`Private`cloud, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[]], 
        Pattern[CloudObject`Private`elements, 
         Blank[]], 
        Pattern[CloudObject`Private`options, 
         BlankNullSequence[]]] := (
       CloudObject`Private`fetchObjURLAsync[
        CloudObject`Private`cloud, CloudObject`Private`url, Null, 
         CloudObject`Private`options]; {200, {}, {}}), Condition[
        CloudObject`Private`fetchObjURLAsync[
         Pattern[CloudObject`Private`cloud, 
          Blank[]], 
         Pattern[CloudObject`Private`url, 
          Blank[]], 
         Pattern[CloudObject`Private`callback, 
          Blank[]], 
         Pattern[CloudObject`Private`options, 
          BlankNullSequence[]]], 
        CloudObject`Private`useUnauthenticatedRequestQ[
        CloudObject`Private`cloud]] := 
      URLFetchAsynchronous[
       CloudObject`Private`url, CloudObject`Private`callback, 
        CloudObject`Private`options], CloudObject`Private`fetchObjURLAsync[
        Pattern[CloudObject`Private`cloud, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[]], 
        Pattern[CloudObject`Private`callback, 
         Blank[]], 
        Pattern[CloudObject`Private`options, 
         BlankNullSequence[]]] := 
      Block[{$CloudBase = CloudObject`Private`cloud}, 
        CloudObject`Private`authenticatedURLFetchAsynchronous[
        CloudObject`Private`url, CloudObject`Private`callback, 
         CloudObject`Private`options]], 
      CloudObject`Private`useUnauthenticatedRequestQ[
        Pattern[CloudObject`Private`cloud, 
         Blank[]]] := And[
        TrueQ[$CloudEvaluation], 
        Not[
         CloudObject`Private`sameCloudQ[
         CloudObject`Private`cloud, $EvaluationCloudBase]]], 
      CloudObject`Private`sameCloudQ[
        Pattern[CloudObject`Private`cloud1, 
         Blank[]], 
        Pattern[CloudObject`Private`cloud2, 
         Blank[]]] := (
       CloudObject`Private`sameCloudQ[
        CloudObject`Private`cloud1, CloudObject`Private`cloud2] = Apply[SameQ, 
         Map[
         CloudObject`Private`normalizeCloudServer, {
          CloudObject`Private`cloud1, CloudObject`Private`cloud2}]]), 
      CloudObject`Private`normalizeCloudServer[
        Pattern[CloudObject`Private`cloud, 
         Blank[]]] := (
       CloudObject`Private`normalizeCloudServer[CloudObject`Private`cloud] = 
       StringReplace[
         URLParse[CloudObject`Private`cloud, "Domain"], 
         StringExpression[StartOfString, "datadrop."] -> "www."]), 
      Attributes[URLFetchAsynchronous] = {ReadProtected}, 
      Options[URLFetchAsynchronous] = {
       Method -> "GET", "Parameters" -> {}, "Body" -> "", 
        "MultipartElements" -> {}, "VerifyPeer" -> True, "Username" -> None, 
        "Password" -> None, "UserAgent" -> Automatic, CookieFunction -> 
        Automatic, "Cookies" -> Automatic, "StoreCookies" -> True, 
        "Headers" -> {}, "CredentialsProvider" -> Automatic, "ConnectTimeout" -> 
        0, "ReadTimeout" -> 0, "OAuthAuthentication" -> None, 
        "FollowRedirects" -> True, "ProxyUsername" -> "", "ProxyPassword" -> 
        "", "Debug" -> False, ConnectionSettings -> 
        Association[
         "MaxUploadSpeed" -> Automatic, "MaxDownloadSpeed" -> Automatic], 
        "DisplayProxyDialog" -> False, "Progress" -> False, "Transfer" -> 
        Automatic, "UserData" -> None, "Events" -> Automatic}, 
      CloudObject`Private`authenticatedURLFetchAsynchronous[
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`callback, 
         Blank[]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := 
      CloudObject`Private`doAuthenticatedURLFetch[
       URLFetchAsynchronous, CloudObject`Private`url, 
        CloudObject`Private`callback, CloudObject`Private`opts], 
      CloudObject`Private`doAuthenticatedURLFetch[
        Pattern[CloudObject`Private`func, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`param, 
         Blank[]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := If[$CloudConnected, 
        CloudObject`Private`enforcedAuthenticatedURLFetch[
        CloudObject`Private`func, CloudObject`Private`url, 
         CloudObject`Private`param, CloudObject`Private`opts], 
        CloudObject`Private`lazyAuthenticatedURLFetch[
        CloudObject`Private`func, CloudObject`Private`url, 
         CloudObject`Private`param, CloudObject`Private`opts]], 
      CloudObject`Private`doAuthenticatedURLFetch[
        Pattern[CloudObject`Private`func, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`file, 
         Blank[]], 
        Pattern[CloudObject`Private`param, 
         Blank[]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := If[$CloudConnected, 
        CloudObject`Private`enforcedAuthenticatedURLFetch[
        CloudObject`Private`func, CloudObject`Private`url, 
         CloudObject`Private`file, CloudObject`Private`param, 
         CloudObject`Private`opts], 
        CloudObject`Private`lazyAuthenticatedURLFetch[
        CloudObject`Private`func, CloudObject`Private`url, 
         CloudObject`Private`file, CloudObject`Private`param, 
         CloudObject`Private`opts]], 
      CloudObject`Private`enforcedAuthenticatedURLFetch[
        Pattern[CloudObject`Private`func, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`param, 
         BlankSequence[]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := Catch[If[
          Not[
           CloudObject`Private`connectedCloudQ[$CloudBase]], 
          CloudConnect[]]; With[{CloudObject`Private`method = Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Method"], {
              MessageName[OptionValue, "nodef"]}], 
           CloudObject`Private`headers = Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Headers"], {
              MessageName[OptionValue, "nodef"]}], CloudObject`Private`body = 
           Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Body"], {
              MessageName[OptionValue, "nodef"]}], CloudObject`Private`params = 
           Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Parameters"], {
              MessageName[OptionValue, "nodef"]}], 
           CloudObject`Private`options = Apply[Sequence, 
             FilterRules[{CloudObject`Private`opts}, 
              Except[
               Alternatives["Method", "Headers"]]]]}, 
          
          With[{CloudObject`Private`auth = 
            CloudObject`Private`makeOAuthHeader[
             CloudObject`Private`url, CloudObject`Private`method, 
              CloudObject`Private`getContentTypeFromHeaders[
              CloudObject`Private`headers], CloudObject`Private`body, 
              CloudObject`Private`params]}, 
           CloudObject`Private`connectionLog["Headers: ", 
             Join[
             CloudObject`Private`headers, {
              "Authorization" -> CloudObject`Private`auth}]]; 
           CloudObject`Private`connectionLog[
            CloudObject`Private`method, CloudObject`Private`url]; 
           CloudObject`Private`connectionLog[
            "Options: ", CloudObject`Private`options]; Check[
             CloudObject`Private`func[
             CloudObject`Private`url, CloudObject`Private`param, "Method" -> 
              CloudObject`Private`method, "Headers" -> 
              Join[CloudObject`Private`headers, {
                "Authorization" -> CloudObject`Private`auth}], 
              CloudObject`Private`options], 
             Throw[$Failed, CloudObject`Private`$tag]]]], 
        CloudObject`Private`$tag], 
      CloudObject`Private`enforcedAuthenticatedURLFetch[
        Pattern[CloudObject`Private`func, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`file, 
         Blank[]], 
        Pattern[CloudObject`Private`param, 
         BlankSequence[]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := Catch[If[
          Not[
           CloudObject`Private`connectedCloudQ[$CloudBase]], 
          CloudConnect[]]; With[{CloudObject`Private`method = Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Method"], {
              MessageName[OptionValue, "nodef"]}], 
           CloudObject`Private`headers = Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Headers"], {
              MessageName[OptionValue, "nodef"]}], CloudObject`Private`body = 
           Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Body"], {
              MessageName[OptionValue, "nodef"]}], CloudObject`Private`params = 
           Quiet[
             OptionValue[URLFetch, {CloudObject`Private`opts}, "Parameters"], {
              MessageName[OptionValue, "nodef"]}], 
           CloudObject`Private`options = Apply[Sequence, 
             FilterRules[{CloudObject`Private`opts}, 
              Except[
               Alternatives["Method", "Headers"]]]]}, 
          
          With[{CloudObject`Private`auth = 
            CloudObject`Private`makeOAuthHeader[
             CloudObject`Private`url, CloudObject`Private`method, 
              CloudObject`Private`getContentTypeFromHeaders[
              CloudObject`Private`headers], CloudObject`Private`body, 
              CloudObject`Private`params]}, 
           CloudObject`Private`connectionLog["Headers: ", 
             Join[
             CloudObject`Private`headers, {
              "Authorization" -> CloudObject`Private`auth}]]; 
           CloudObject`Private`connectionLog[
            CloudObject`Private`method, CloudObject`Private`url]; 
           CloudObject`Private`connectionLog[
            "Options: ", CloudObject`Private`options]; Check[
             CloudObject`Private`func[
             CloudObject`Private`url, CloudObject`Private`file, 
              CloudObject`Private`param, "Method" -> 
              CloudObject`Private`method, "Headers" -> 
              Join[CloudObject`Private`headers, {
                "Authorization" -> CloudObject`Private`auth}], 
              CloudObject`Private`options], 
             Throw[$Failed, CloudObject`Private`$tag]]]], 
        CloudObject`Private`$tag], CloudObject`Private`connectedCloudQ[
        Pattern[CloudObject`Private`cloud, 
         Blank[]]] := 
      Which[
       CloudObject`Private`cloud === CloudObject`Private`$connectedCloud, 
        True, CloudObject`Private`extractURLDomain[CloudObject`Private`cloud] === 
        CloudObject`Private`$connectedCloud, True, True, False], 
      CloudObject`Private`$connectedCloud = None, 
      CloudObject`Private`extractURLDomain[
        Pattern[CloudObject`Private`url, 
         Blank[String]]] := With[{CloudObject`Private`d = Quiet[
           URLParse[CloudObject`Private`url, "Domain"]]}, 
        If[
         StringQ[CloudObject`Private`d], 
         CloudObject`Private`extractURLDomain[CloudObject`Private`url] = 
         CloudObject`Private`d, CloudObject`Private`url]], 
      CloudObject`Private`extractURLDomain[
        Pattern[CloudObject`Private`other, 
         BlankSequence[]]] := CloudObject`Private`other, 
      Attributes[URLFetch] = {ReadProtected}, 
      Options[URLFetch] := {
       Method -> "GET", "Parameters" -> {}, "Body" -> "", 
        "MultipartElements" -> {}, "VerifyPeer" -> True, "Username" -> None, 
        "Password" -> None, "UserAgent" -> Automatic, CookieFunction -> 
        Automatic, "Cookies" -> Automatic, "StoreCookies" -> True, 
        "Headers" -> {}, "CredentialsProvider" -> Automatic, "ConnectTimeout" -> 
        0, "ReadTimeout" -> 0, "DisplayProxyDialog" -> True, 
        "OAuthAuthentication" -> None, "FollowRedirects" -> True, 
        "ProxyUsername" -> "", "ProxyPassword" -> "", "Debug" -> False, 
        ConnectionSettings -> 
        Association[
         "MaxUploadSpeed" -> Automatic, "MaxDownloadSpeed" -> Automatic]}, 
      CloudObject`Private`makeOAuthHeader[
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]], 
        Pattern[CloudObject`Private`ctype, 
         Blank[]], 
        Pattern[CloudObject`Private`body, 
         Blank[]], 
        Pattern[CloudObject`Private`params, 
         Blank[]]] := 
      With[{CloudObject`Private`non = CloudObject`Private`nonce[], 
         CloudObject`Private`time = CloudObject`Private`unixtime[]}, 
        StringJoin[
        "OAuth realm=\"", CloudObject`Private`$signatureURL, 
         "\", oauth_consumer_key=\"", 
         CloudObject`Private`getConsumerKey[], "\", oauth_token=\"", 
         CloudObject`Private`getAccessToken[], "\", oauth_nonce=\"", 
         CloudObject`Private`non, "\", oauth_timestamp=\"", 
         ToString[CloudObject`Private`time], "\", oauth_signature_method=\"", 
         CloudObject`Private`$sigMethod, "\", oauth_version=\"", 
         CloudObject`Private`$oauthVersion, "\", oauth_signature=\"", 
         ExternalService`EncodeString[
          
          CloudObject`Private`makeSignature[{
           CloudObject`Private`non, CloudObject`Private`time}, 
           CloudObject`Private`url, CloudObject`Private`method, 
           CloudObject`Private`ctype, CloudObject`Private`body, 
           CloudObject`Private`params]], "\""]], 
      CloudObject`Private`makeOAuthHeader[
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]]] := 
      CloudObject`Private`makeOAuthHeader[
       CloudObject`Private`url, CloudObject`Private`method, "None", None, 
        None], CloudObject`Private`makeOAuthHeader[
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]], 
        Pattern[CloudObject`Private`ctype, 
         Blank[]], 
        Pattern[CloudObject`Private`body, 
         Blank[]]] := 
      CloudObject`Private`makeOAuthHeader[
       CloudObject`Private`url, CloudObject`Private`method, 
        CloudObject`Private`ctype, CloudObject`Private`body, None], 
      CloudObject`Private`nonce[] := StringJoin[
        RandomChoice[CloudObject`Private`$randomCharacters, 20]], 
      CloudObject`Private`$randomCharacters = {
       "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", 
        "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", 
        "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", 
        "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", 
        "u", "v", "w", "x", "y", "z"}, CloudObject`Private`unixtime[] := 
      Round[AbsoluteTime[TimeZone -> 0] - CloudObject`Private`$unixtimebase], 
      CloudObject`Private`$unixtimebase = 2208988800, 
      CloudObject`Private`$signatureURL := 
      CloudObject`Private`makeSignatureURL[$CloudBase], 
      CloudObject`Private`makeSignatureURL["datadrop.test.wolframcloud.com"] = 
      "https://datadrop.test.wolframcloud.com", 
      CloudObject`Private`makeSignatureURL["datadrop.wolframcloud.com"] = 
      "https://datadrop.wolframcloud.com", 
      CloudObject`Private`makeSignatureURL["localhost"] := "http://localhost",
       CloudObject`Private`makeSignatureURL["localhost:8080/app"] := 
      "http://localhost:8080", 
      CloudObject`Private`makeSignatureURL[
       "oadeployment.devel.wolframcloud.com"] := 
      "https://oadeployment.devel.wolframcloud.com", 
      CloudObject`Private`makeSignatureURL[
       "oadeployment.test.wolframcloud.com"] := 
      "https://oadeployment.test.wolframcloud.com", 
      CloudObject`Private`makeSignatureURL["oadeployment.wolframcloud.com"] := 
      "https://oadeployment.wolframcloud.com", 
      CloudObject`Private`makeSignatureURL["www.devel.wolframcloud.com"] := 
      "https://devel.wolframcloud.com", 
      CloudObject`Private`makeSignatureURL["www.test.wolframcloud.com"] := 
      "https://test.wolframcloud.com", 
      CloudObject`Private`makeSignatureURL["www.wolframcloud.com"] := 
      "https://wolframcloud.com", Condition[
        CloudObject`Private`makeSignatureURL[
         Pattern[CloudObject`Private`url, 
          Blank[String]]], 
        Not[
         TrueQ[CloudObject`Private`$getDomainFlag]]] := 
      Block[{CloudObject`Private`$getDomainFlag = True, 
         CloudObject`Private`res}, CloudObject`Private`res = Catch[
           CloudObject`Private`makeSignatureURL[
            CloudObject`Private`getDomain[CloudObject`Private`url]], 
           CloudObject`Private`$tag]; 
        If[CloudObject`Private`res === $Failed, 
          CloudObject`Private`automaticSignatureURL[CloudObject`Private`url], 
          CloudObject`Private`res]], CloudObject`Private`makeSignatureURL[
        BlankNullSequence[]] := Throw[$Failed, CloudObject`Private`$tag], 
      CloudObject`Private`getDomain[
        Pattern[CloudObject`Private`value, 
         Blank[]]] := 
      StringReplace[CloudObject`Private`value, StringExpression[
          Alternatives["http://", "https://", ""], 
          Shortest[
           Pattern[CloudObject`Private`domain, 
            Blank[]]], 
          RegularExpression["(:[0-9]+)?(/.*)?"]] :> 
        CloudObject`Private`domain], CloudObject`Private`automaticSignatureURL[
        Pattern[CloudObject`Private`base, 
         Blank[String]]] := 
      Module[{CloudObject`Private`sig = 
         StringReplace[
          CloudObject`Private`base, "https://www." -> "http://"]}, 
        If[
         StringMatchQ[CloudObject`Private`sig, 
          StringExpression[
           BlankSequence[], "/"]], 
         StringDrop[CloudObject`Private`sig, -1], CloudObject`Private`sig]], 
      CloudObject`Private`getConsumerKey = 
      LibraryFunction[
       "C:\\Program Files\\Wolfram \
Research\\Mathematica\\12.1\\SystemFiles\\Links\\CloudObject\\\
LibraryResources\\Windows-x86-64\\WolframAuthenticate.dll", 
        "get_consumer_key", {}, "UTF8String"], 
      CloudObject`Private`getAccessToken = 
      LibraryFunction[
       "C:\\Program Files\\Wolfram \
Research\\Mathematica\\12.1\\SystemFiles\\Links\\CloudObject\\\
LibraryResources\\Windows-x86-64\\WolframAuthenticate.dll", 
        "get_access_key", {}, "UTF8String"], CloudObject`Private`$sigMethod = 
      "HMAC-SHA1", CloudObject`Private`$oauthVersion = "1.0", 
      CloudObject`Private`makeSignature[{
         Pattern[CloudObject`Private`non, 
          Blank[]], 
         Pattern[CloudObject`Private`time, 
          Blank[]]}, 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]], 
        Pattern[CloudObject`Private`ctype, 
         Blank[]], 
        Pattern[CloudObject`Private`body, 
         Blank[]], 
        Pattern[CloudObject`Private`params, 
         Blank[]]] := 
      With[{CloudObject`Private`sigBase = 
         CloudObject`Private`makeSignatureBase[{
           CloudObject`Private`non, CloudObject`Private`time}, 
           CloudObject`Private`url, CloudObject`Private`method, 
           CloudObject`Private`ctype, CloudObject`Private`body, 
           CloudObject`Private`params]}, 
        CloudObject`Private`connectionLog[
         "Signature base: ", CloudObject`Private`sigBase]; 
        CloudObject`Private`CloudHMAC[CloudObject`Private`sigBase, "Access"]],
       CloudObject`Private`makeSignatureBase[{
         Pattern[CloudObject`Private`non, 
          Blank[]], 
         Pattern[CloudObject`Private`time, 
          Blank[]]}, 
        Pattern[CloudObject`Private`url, 
         Blank[]], 
        Pattern[CloudObject`Private`method, 
         Blank[]], 
        Pattern[CloudObject`Private`ctype, 
         Blank[]], 
        Pattern[CloudObject`Private`body, 
         Blank[]], 
        Pattern[CloudObject`Private`params, 
         Blank[]]] := 
      With[{CloudObject`Private`version = 
         CloudObject`Private`getOAuthSignatureVersion[$CloudBase]}, 
        Switch[CloudObject`Private`version, "1.0a", 
         CloudObject`Private`makeSignatureBaseV2[{
          CloudObject`Private`non, CloudObject`Private`time}, 
          CloudObject`Private`url, CloudObject`Private`method, 
          CloudObject`Private`ctype, CloudObject`Private`body, 
          CloudObject`Private`params], 
         Blank[], 
         CloudObject`Private`makeSignatureBaseV1[{
          CloudObject`Private`non, CloudObject`Private`time}, 
          CloudObject`Private`url, CloudObject`Private`method]]], 
      CloudObject`Private`getOAuthSignatureVersion[
        Pattern[CloudObject`Private`server, 
         Blank[]]] := If[
        MissingQ[CloudObject`Private`$OAuthSignatureVersion], 
        CloudObject`Private`requestAndSetOAuthSignatureVersion[
        CloudObject`Private`server], 
        CloudObject`Private`$OAuthSignatureVersion], 
      CloudObject`Private`requestAndSetOAuthSignatureVersion[
        Pattern[CloudObject`Private`server, 
         Blank[]]] := 
      Module[{CloudObject`Private`status, CloudObject`Private`content}, 
        Quiet[{CloudObject`Private`status, CloudObject`Private`content} = 
           CloudObject`Private`fetchOAuthVersion[
            CloudObject`Private`$oauthVersionURL]; 
          If[CloudObject`Private`status =!= 
            200, {CloudObject`Private`status, CloudObject`Private`content} = 
            CloudObject`Private`fetchOAuthVersion[
             CloudObject`Private`$legacyOAuthVersionURL]]]; If[
          StringQ[CloudObject`Private`content], CloudObject`Private`content = 
          StringTrim[CloudObject`Private`content]]; 
        Switch[{CloudObject`Private`status, CloudObject`Private`content}, {
          200, "1.0a"}, 
          CloudObject`Private`SetOAuthSignatureVersionStatus[
          CloudObject`Private`server, "1.0a"], 
          Blank[], 
          CloudObject`Private`SetOAuthSignatureVersionStatus[
          CloudObject`Private`server, None]]], 
      CloudObject`Private`fetchOAuthVersion[
        Pattern[CloudObject`Private`url, 
         Blank[]]] := 
      URLFetch[CloudObject`Private`url, {"StatusCode", "Content"}, 
        "FollowRedirects" -> False], CloudObject`Private`$oauthVersionURL := 
      URLBuild[{$CloudBase, "OAuthVersion"}], 
      CloudObject`Private`$legacyOAuthVersionURL := 
      URLBuild[{$CloudBase, "app", "OAuthVersion"}], 
      CloudObject`Private`SetOAuthSignatureVersionStatus[
        Pattern[CloudObject`Private`server, 
         Blank[String]], 
        Pattern[CloudObject`Private`status, 
         Blank[]]] := (CloudObject`Private`$OAuthSigVersion[
         CloudObject`Private`extractURLDomain[CloudObject`Private`server]] = 
       CloudObject`Private`status), CloudObject`Private`$OAuthSigVersion = 
      Association[], CloudObject`Private`makeSignatureBaseV2[{
         Pattern[CloudObject`Private`non, 
          Blank[]], 
         Pattern[CloudObject`Private`time, 
          Blank[]]}, 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]], 
        Pattern[CloudObject`Private`ctype, 
         Blank[]], 
        Pattern[CloudObject`Private`body, 
         Blank[]], 
        Pattern[CloudObject`Private`params, 
         Blank[]]] := 
      Module[{CloudObject`Private`baseurl, 
         CloudObject`Private`parameters}, {
          CloudObject`Private`baseurl, CloudObject`Private`parameters} = 
         CloudObject`Private`partitionURLAndParameters[
          CloudObject`Private`url]; 
        CloudObject`Private`parameters = 
         Join[CloudObject`Private`parameters, {
           "oauth_nonce" -> CloudObject`Private`non, "oauth_timestamp" -> 
            ToString[CloudObject`Private`time]}]; If[
          And[
           StringQ[CloudObject`Private`ctype], 
           StringStartsQ[
           CloudObject`Private`ctype, "application/x-www-form-urlencoded"], 
           CloudObject`Private`body =!= ""], CloudObject`Private`parameters = 
          Join[CloudObject`Private`parameters, 
            CloudObject`Private`getBodyParameters[CloudObject`Private`body]]]; 
        CloudObject`Private`parameters = 
         Join[CloudObject`Private`parameters, 
           CloudObject`Private`getParameters[CloudObject`Private`params]]; 
        StringJoin[CloudObject`Private`method, "&", 
          ExternalService`EncodeString[CloudObject`Private`baseurl], "&", 
          CloudObject`Private`makeSubString[CloudObject`Private`parameters]]],
       CloudObject`Private`partitionURLAndParameters[
        Pattern[CloudObject`Private`url, 
         Blank[String]]] := 
      Module[{CloudObject`Private`urldata = URLParse[CloudObject`Private`url],
          CloudObject`Private`baseurl, CloudObject`Private`parameters}, 
        CloudObject`Private`parameters = CloudObject`Private`urldata["Query"]; 
        CloudObject`Private`urldata["Query"] = {}; 
        CloudObject`Private`baseurl = URLBuild[CloudObject`Private`urldata]; {
         CloudObject`Private`baseurl, CloudObject`Private`parameters}], 
      CloudObject`Private`getBodyParameters[
        Pattern[CloudObject`Private`body, {
          Repeated[
           Blank[Integer]]}]] := CloudObject`Private`getBodyParameters[
        FromCharacterCode[CloudObject`Private`body]], 
      CloudObject`Private`getBodyParameters[
        Pattern[CloudObject`Private`str, 
         Blank[String]]] := URLQueryDecode[CloudObject`Private`str], 
      CloudObject`Private`getBodyParameters[
        BlankNullSequence[]] := {}, CloudObject`Private`getParameters[
        Pattern[CloudObject`Private`params, {
          BlankSequence[Rule]}]] := CloudObject`Private`params, 
      CloudObject`Private`getParameters[
        BlankNullSequence[]] := {}, CloudObject`Private`makeSubString[{
         Pattern[CloudObject`Private`non, 
          Blank[String]], 
         Pattern[CloudObject`Private`time, 
          Blank[]]}] := ExternalService`EncodeString[
        StringJoin["oauth_consumer_key=", 
         CloudObject`Private`getConsumerKey[], "&oauth_nonce=", 
         CloudObject`Private`non, "&oauth_signature_method=", 
         CloudObject`Private`$sigMethod, "&oauth_timestamp=", 
         ToString[CloudObject`Private`time], "&oauth_token=", 
         CloudObject`Private`getAccessToken[], "&oauth_version=", 
         CloudObject`Private`$oauthVersion]], 
      CloudObject`Private`makeSubString[
        Pattern[CloudObject`Private`parameters, {
          Repeated[
           Blank[Rule]]}]] := With[{CloudObject`Private`sorted = Sort[
           Join[
           CloudObject`Private`parameters, 
            CloudObject`Private`$oauthParameters], 
           CloudObject`Private`oauthSigningSorter]}, 
        URLEncode[
         CloudObject`Private`oAuthQueryEncode[CloudObject`Private`sorted]]], 
      CloudObject`Private`$oauthParameters = {
       "oauth_consumer_key" :> CloudObject`Private`getConsumerKey[], 
        "oauth_signature_method" :> CloudObject`Private`$sigMethod, 
        "oauth_token" :> CloudObject`Private`getAccessToken[], 
        "oauth_version" :> CloudObject`Private`$oauthVersion}, 
      CloudObject`Private`oauthSigningSorter[
        Blank[][
         Pattern[CloudObject`Private`key1, 
          Blank[String]], 
         Pattern[CloudObject`Private`value1, 
          Blank[]]], 
        Blank[][
         Pattern[CloudObject`Private`key2, 
          Blank[String]], 
         Pattern[CloudObject`Private`value2, 
          Blank[]]]] := Module[{CloudObject`Private`maxLen = Max[
           Map[
           StringLength, {
            CloudObject`Private`key1, CloudObject`Private`value1, 
             CloudObject`Private`key2, CloudObject`Private`value2}]], 
         CloudObject`Private`res}, CloudObject`Private`res = Map[PadRight[
            ToCharacterCode[#], CloudObject`Private`maxLen]& , {
           CloudObject`Private`key1, CloudObject`Private`key2}]; If[
          TrueQ[
           Apply[Equal, CloudObject`Private`res]], 
          OrderedQ[
           Map[PadRight[
             ToCharacterCode[#], CloudObject`Private`maxLen]& , {
            CloudObject`Private`value1, CloudObject`Private`value2}]], 
          OrderedQ[CloudObject`Private`res]]], 
      CloudObject`Private`oAuthQueryEncode[
        Pattern[CloudObject`Private`args, 
         Blank[]]] := StringReplace[
        URLQueryEncode[CloudObject`Private`args], "+" -> "%20"], 
      CloudObject`Private`makeSignatureBaseV1[{
         Pattern[CloudObject`Private`non, 
          Blank[]], 
         Pattern[CloudObject`Private`time, 
          Blank[]]}, 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`method, 
         Blank[String]]] := StringJoin[CloudObject`Private`method, "&", 
        ExternalService`EncodeString[CloudObject`Private`$signatureURL], "&", 
        
        CloudObject`Private`makeSubString[{
         CloudObject`Private`non, CloudObject`Private`time}]], Condition[
        CloudObject`Private`connectionLog[
         Pattern[CloudObject`Private`message, 
          BlankSequence[]]], CloudObject`$LogConnectionInformation] := 
      AbortProtect[
        Module[{CloudObject`Private`out}, 
         CloudObject`Private`out = 
          OpenAppend[
           CloudObject`Private`$connectionLogFile, PageWidth -> Infinity, 
            FormatType -> OutputForm]; Quiet[
           Write[CloudObject`Private`out, 
            DateString[{"ISODateTime", ".", "Millisecond"}], " ", 
            Apply[Sequence, 
             Riffle[{CloudObject`Private`message}, " "]]]]; 
         Close[CloudObject`Private`out]]], 
      CloudObject`$LogConnectionInformation := (
       CloudObject`$LogConnectionInformation = TrueQ[
         CloudObject`Private`connectionLoggingEnabledQ[]]), 
      TagSet[CloudObject`$LogConnectionInformation, 
       MessageName[CloudObject`$LogConnectionInformation, "usage"], 
       "CloudObject`$LogConnectionInformation specifies whether to log \
connection info or not."], CloudObject`Private`connectionLoggingEnabledQ[] := 
      FileExistsQ[CloudObject`Private`$connectionLogConfigurationFile], 
      CloudObject`Private`$connectionLogConfigurationFile := (
       CloudObject`Private`$connectionLogConfigurationFile = 
       FileNameJoin[{CloudObject`Private`$credsDir, "logging.conf"}]), 
      CloudObject`Private`$credsDir = 
      "C:\\Users\\Ksiegarnia\\AppData\\Roaming\\Mathematica\\ApplicationData\\\
CloudObject\\Authentication", CloudObject`Private`$connectionLogFile := (Quiet[
         CreateDirectory[CloudObject`Private`$loggingDir]]; 
       CloudObject`Private`$connectionLogFile = 
        FileNameJoin[{CloudObject`Private`$loggingDir, 
           StringTemplate["`1`-`2`-`3`.log"][
           CloudObject`Private`$kernelName, $ProcessID, $SessionID]}]), 
      CloudObject`Private`$loggingDir = 
      "C:\\Users\\Ksiegarnia\\AppData\\Local\\Temp\\CloudConnect", 
      CloudObject`Private`$kernelName = "Local", $ProcessID = 8484, 
      CloudObject`Private`CloudHMAC = 
      LibraryFunction[
       "C:\\Program Files\\Wolfram \
Research\\Mathematica\\12.1\\SystemFiles\\Links\\CloudObject\\\
LibraryResources\\Windows-x86-64\\WolframAuthenticate.dll", 
        "cloud_object_oauth_hmac", {"UTF8String", "UTF8String"}, 
        "UTF8String"], CloudObject`Private`getContentTypeFromHeaders[
        Pattern[CloudObject`Private`headers, 
         Blank[List]]] := 
      Replace["Content-Type", CloudObject`Private`headers], 
      CloudObject`Private`lazyAuthenticatedURLFetch[
        Pattern[CloudObject`Private`func, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`param, 
         Blank[List]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := Catch[
        With[{CloudObject`Private`method = Quiet[
            OptionValue[URLFetch, {CloudObject`Private`opts}, "Method"], {
             MessageName[OptionValue, "nodef"]}], CloudObject`Private`options = 
          Apply[Sequence, 
            FilterRules[{CloudObject`Private`opts}, 
             Except["Method"]]]}, 
         Module[{CloudObject`Private`res, CloudObject`Private`status}, 
          CloudObject`Private`res = 
           CloudObject`Private`func[CloudObject`Private`url, 
             Prepend[CloudObject`Private`param, "StatusCode"], "Method" -> 
             CloudObject`Private`method, CloudObject`Private`options, 
             "DisplayProxyDialog" -> False]; If[
            ListQ[CloudObject`Private`res], 
            CloudObject`Private`status = First[CloudObject`Private`res]; 
            CloudObject`Private`res = Rest[CloudObject`Private`res], 
            Throw[$Failed, CloudObject`Private`$tag]]; 
          If[CloudObject`Private`status === 401, 
            With[{CloudObject`Private`con = CloudConnect[]}, 
             If[CloudObject`Private`con === $CloudUserID, 
              CloudObject`Private`enforcedAuthenticatedURLFetch[
              CloudObject`Private`func, CloudObject`Private`url, 
               CloudObject`Private`param, CloudObject`Private`opts], 
              CloudObject`Private`HTTPError[401]]], 
            CloudObject`Private`res]]], CloudObject`Private`$tag], 
      CloudObject`Private`lazyAuthenticatedURLFetch[
        Pattern[CloudObject`Private`func, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`file, 
         Blank[]], 
        Pattern[CloudObject`Private`param, 
         Blank[List]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := Catch[
        With[{CloudObject`Private`method = Quiet[
            OptionValue[URLFetch, {CloudObject`Private`opts}, "Method"], {
             MessageName[OptionValue, "nodef"]}], CloudObject`Private`options = 
          Apply[Sequence, 
            FilterRules[{CloudObject`Private`opts}, 
             Except["Method"]]]}, 
         Module[{CloudObject`Private`res, CloudObject`Private`status}, 
          CloudObject`Private`res = 
           CloudObject`Private`func[
            CloudObject`Private`url, CloudObject`Private`file, 
             Prepend[CloudObject`Private`param, "StatusCode"], "Method" -> 
             CloudObject`Private`method, CloudObject`Private`options, 
             "DisplayProxyDialog" -> False]; If[
            ListQ[CloudObject`Private`res], 
            CloudObject`Private`status = First[CloudObject`Private`res]; 
            CloudObject`Private`res = Rest[CloudObject`Private`res], 
            Throw[$Failed, CloudObject`Private`$tag]]; 
          If[CloudObject`Private`status === 401, 
            With[{CloudObject`Private`con = CloudConnect[]}, 
             If[CloudObject`Private`con === $CloudUserID, 
              CloudObject`Private`enforcedAuthenticatedURLFetch[
              CloudObject`Private`func, CloudObject`Private`url, 
               CloudObject`Private`param, CloudObject`Private`opts], 
              CloudObject`Private`HTTPError[401]]], 
            CloudObject`Private`res]]], CloudObject`Private`$tag], 
      CloudObject`Private`lazyAuthenticatedURLFetch[
        Pattern[CloudObject`Private`func, 
         Blank[]], 
        Pattern[CloudObject`Private`args, 
         BlankSequence[]]] := 
      CloudObject`Private`func[CloudObject`Private`args], Condition[
        CloudObject`Private`fetchURL[
         Pattern[CloudObject`Private`cloud, 
          Blank[]], 
         Pattern[CloudObject`Private`url, 
          Blank[]], 
         Pattern[CloudObject`Private`elements, 
          Blank[]], 
         Pattern[CloudObject`Private`options, 
          BlankNullSequence[]]], 
        CloudObject`Private`useUnauthenticatedRequestQ[
        CloudObject`Private`cloud]] := 
      URLFetch[CloudObject`Private`url, CloudObject`Private`elements, 
        CloudObject`Private`options], CloudObject`Private`fetchURL[
        Pattern[CloudObject`Private`cloud, 
         Blank[]], 
        Pattern[CloudObject`Private`url, 
         Blank[]], 
        Pattern[CloudObject`Private`elements, 
         Blank[]], 
        Pattern[CloudObject`Private`options, 
         BlankNullSequence[]]] := 
      Block[{$CloudBase = CloudObject`Private`cloud}, 
        CloudObject`Private`authenticatedURLFetch[
        CloudObject`Private`url, CloudObject`Private`elements, 
         CloudObject`Private`options]], 
      CloudObject`Private`authenticatedURLFetch[
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        Pattern[CloudObject`Private`elements, 
         Except[
          Blank[Rule]]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := 
      CloudObject`Private`doAuthenticatedURLFetch[
       URLFetch, CloudObject`Private`url, CloudObject`Private`elements, 
        CloudObject`Private`opts], CloudObject`Private`authenticatedURLFetch[
        Pattern[CloudObject`Private`url, 
         Blank[String]], 
        PatternTest[
         Pattern[CloudObject`Private`opts, 
          BlankNullSequence[]], OptionQ]] := 
      CloudObject`Private`doAuthenticatedURLFetch[
       URLFetch, CloudObject`Private`url, "Content", 
        CloudObject`Private`opts], CloudObject`Private`verifyPeerQ[] := 
      CloudObject`Private`verifyPeerQ[$CloudBase], 
      CloudObject`Private`verifyPeerQ[
        Pattern[CloudObject`Private`cloud, 
         Blank[]]] := (
       CloudObject`Private`verifyPeerQ[CloudObject`Private`cloud] = 
       MemberQ[CloudObject`Private`httpsClouds, 
         CloudObject`Private`extractURLDomain[CloudObject`Private`cloud]]), 
      CloudObject`Private`httpsClouds = {
       "datadrop.wolframcloud.com", "www.wolframcloud.com", 
        "oadeployment.wolframcloud.com", "www.test.wolframcloud.com", 
        "www.test.masterkernel.wolframcloud.com", 
        "datadrop.test.wolframcloud.com", 
        "oadeployment.test.wolframcloud.com", "www.devel.wolframcloud.com", 
        "oadeployment.devel.wolframcloud.com"}, 
      CloudObject`Private`getHeader[
        Pattern[CloudObject`Private`headers, 
         Blank[List]], 
        Pattern[CloudObject`Private`header, 
         Blank[String]]] := 
      Module[{CloudObject`Private`normRes}, 
        CloudObject`Private`normRes = CloudObject`Private`normalizeHeaders[
           Apply[Rule, CloudObject`Private`headers, {1}]]; 
        Lookup[CloudObject`Private`normRes, CloudObject`Private`header, 
          "text/plain"]], CloudObject`Private`normalizeHeaders[
        Pattern[CloudObject`Private`headers, {
          RepeatedNull[
           Blank[Rule]]}]] := KeyMap[ToLowerCase, 
        Association[CloudObject`Private`headers]], 
      CloudObject`Private`getCloudAndUUID[
        Pattern[CloudObject`Private`obj, 
         CloudObject[
          Pattern[CloudObject`Private`uri, 
           Blank[String]], 
          BlankNullSequence[]]]] := 
      CloudObject`Private`getCloudAndUUID[CloudObject`Private`uri], 
      CloudObject`Private`getCloudAndUUID[
        Pattern[CloudObject`Private`uri, 
         Blank[String]]] := 
      Module[{
        CloudObject`Private`cloud, CloudObject`Private`uuid, 
         CloudObject`Private`user, CloudObject`Private`path, 
         CloudObject`Private`ext, CloudObject`Private`extraPath, 
         CloudObject`Private`search, 
         CloudObject`Private`urlType}, {
          CloudObject`Private`cloud, CloudObject`Private`uuid, 
           CloudObject`Private`user, CloudObject`Private`path, 
           CloudObject`Private`ext, CloudObject`Private`extraPath, 
           CloudObject`Private`search, CloudObject`Private`urlType} = 
         CloudObject`Private`parseURI[CloudObject`Private`uri]; 
        If[CloudObject`Private`uuid === None, CloudObject`Private`uuid = 
          CloudObject`Private`getUUID[
           CloudObject`Private`cloud, {
            CloudObject`Private`user, CloudObject`Private`path}], 
          If[
          CloudObject`Private`extraPath =!= {}, CloudObject`Private`uuid = 
           CloudObject`Private`getUUID[
            CloudObject`Private`cloud, {
             CloudObject`Private`uuid, CloudObject`Private`extraPath}]]]; {
         CloudObject`Private`cloud, CloudObject`Private`uuid}], 
      CloudObject`Private`getCloudAndUUID[
        Pattern[CloudObject`Private`x, 
         Blank[]]] := {None, None}, CloudObject`Private`getUUID[
        CloudObject[
         Pattern[CloudObject`Private`uri, 
          Blank[String]], 
         BlankNullSequence[]]] := Replace[
        CloudObject`Private`parseURI[CloudObject`Private`uri], {{
           Blank[], 
           Pattern[CloudObject`Private`uuid, 
            Blank[String]], 
           BlankSequence[]} :> CloudObject`Private`uuid, Blank[] :> $Failed}],
       CloudObject`Private`getUUID[
        Blank[]] := $Failed, CloudObject`Private`getUUID[
        Pattern[CloudObject`Private`cloud, 
         Blank[]], 
        Pattern[CloudObject`Private`path, 
         Blank[]]] := 
      Module[{CloudObject`Private`pathString, CloudObject`Private`result, 
         CloudObject`Private`uuid}, 
        CloudObject`Private`pathString = 
         CloudObject`JoinURL[CloudObject`Private`path]; 
        CloudObject`Private`result = Quiet[
           CloudObject`Private`responseToString[
            CloudObject`Private`execute[
            CloudObject`Private`cloud, "GET", {"files"}, 
             CloudObject`Private`Parameters -> {
              "path" -> CloudObject`Private`pathString, "fields" -> "uuid"}]], 
           MessageName[CloudObject, "cloudnf"]]; 
        CloudObject`Private`uuid = 
         Replace[CloudObject`Private`result, 
           Pattern[CloudObject`Private`res, 
             Blank[String]] :> Lookup[
             CloudObject`Private`importFromJSON[CloudObject`Private`result], 
             "uuid", None]]; 
        CloudObject`Private`log[
         "UUID for path `1`: `2`", CloudObject`Private`pathString, 
          CloudObject`Private`uuid]; If[
          MatchQ[CloudObject`Private`uuid, {
            Blank[String]}], 
          First[CloudObject`Private`uuid], None]], 
      CloudObject`Private`responseToString[{
         Pattern[CloudObject`Private`type, 
          Blank[]], 
         Pattern[CloudObject`Private`content, 
          Blank[List]]}, 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := FromCharacterCode[CloudObject`Private`content, "UTF-8"],
       CloudObject`Private`responseToString[{
         Pattern[CloudObject`Private`type, 
          Blank[]], 
         Pattern[CloudObject`Private`content, 
          Blank[String]]}, 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := CloudObject`Private`content, 
      CloudObject`Private`responseToString[
        Pattern[CloudObject`Private`response, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Condition[$Failed, 
        CloudObject`Private`checkError[
        CloudObject`Private`response, CloudObject`Private`head]], 
      CloudObject`Private`responseToString[
        Pattern[CloudObject`Private`response, 
         Blank[]]] := 
      CloudObject`Private`responseToString[
       CloudObject`Private`response, CloudObject], 
      CloudObject`Private`checkError[
        Pattern[CloudObject`Private`response, 
         Blank[]], 
        Optional[
         Pattern[CloudObject`Private`msghd, 
          Blank[Symbol]], CloudObject]] := 
      If[CloudObject`Private`response === {$Failed, $Failed}, True, 
        With[{CloudObject`Private`res = MatchQ[CloudObject`Private`response, 
            CloudObject`Private`HTTPError[
             Blank[Integer], 
             BlankNullSequence[]]]}, If[CloudObject`Private`res, 
           Switch[CloudObject`Private`response, 
            CloudObject`Private`HTTPError[
             Alternatives[400, 412], 
             Condition[
              Pattern[CloudObject`Private`rules, {
                BlankSequence[Rule]}], 
              And[
               KeyExistsQ[CloudObject`Private`rules, "errorCode"], 
               KeyExistsQ[CloudObject`Private`rules, "extraData"]]], 
             BlankNullSequence[]], 
            CloudObject`Private`handleErrorDetails[
             Lookup[
              Part[CloudObject`Private`response, 2], "errorCode"], 
             Lookup[
              Part[CloudObject`Private`response, 2], "extraData"], 
             CloudObject`Private`msghd], 
            CloudObject`Private`HTTPError[
             Alternatives[400, 403, 503, 521, 523, 532, 533], 
             Condition[
              Pattern[CloudObject`Private`rules, {
                BlankSequence[Rule]}], 
              And[
               KeyExistsQ[CloudObject`Private`rules, "errorCode"], 
               KeyExistsQ[CloudObject`Private`rules, "errorDetails"]]], 
             BlankNullSequence[]], 
            CloudObject`Private`handleErrorDetails[
             Lookup[
              Part[CloudObject`Private`response, 2], "errorCode"], 
             Lookup[
              Part[CloudObject`Private`response, 2], "errorDetails"], 
             CloudObject`Private`msghd], 
            CloudObject`Private`HTTPError[400, 
             Condition[
              Pattern[CloudObject`Private`rules, {
                BlankSequence[Rule]}], 
              KeyExistsQ[CloudObject`Private`rules, "failures"]], 
             BlankNullSequence[]], 
            CloudObject`Private`processFailureJSONObj[
             Part[CloudObject`Private`response, 2], 
             CloudObject`Private`msghd], 
            CloudObject`Private`HTTPError[400, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "notparam"]], 
            CloudObject`Private`HTTPError[401, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "notauth"]], 
            CloudObject`Private`HTTPError[403, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "notperm"]], 
            CloudObject`Private`HTTPError[404, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "cloudnf"]], 
            CloudObject`Private`HTTPError[405, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "notmethod"]], 
            CloudObject`Private`HTTPError[409, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "locked"]], 
            CloudObject`Private`HTTPError[412, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "cloudprecondition"]], 
            CloudObject`Private`HTTPError[429, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "rejreq"]], 
            CloudObject`Private`HTTPError[
             Alternatives[500, 515], 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "srverr"]], 
            CloudObject`Private`HTTPError[503, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "unavailable"]], 
            CloudObject`Private`HTTPError[531, 
             BlankNullSequence[]], 
            Message[
             MessageName[CloudObject`Private`msghd, "insuffcredits"]], 
            Blank[], 
            Message[
             MessageName[CloudObject`Private`msghd, "cloudunknown"]]]]; 
         CloudObject`Private`res]], 
      CloudObject`Private`handleErrorDetails["max-viewers", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "maxviewers"], 
        CloudObject`Private`extra], 
      CloudObject`Private`handleErrorDetails["unknown-user", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "userunknown"], 
        CloudObject`Private`extra], 
      CloudObject`Private`handleErrorDetails["user-not-found", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "invusr"], 
        CloudObject`Private`extra], 
      CloudObject`Private`handleErrorDetails["MemoryLimitExceeded", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "memorylimit"], 
        CloudObject`Private`extra], 
      CloudObject`Private`handleErrorDetails["TimeLimitExceeded", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "timelimit"], 
        CloudObject`Private`extra], 
      CloudObject`Private`handleErrorDetails["branding-level-not-supported", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "appearancenotsup"], 
        Part[CloudObject`Private`extra, 1]], 
      CloudObject`Private`handleErrorDetails["no-wolfram-engine-response", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "unavailable"], 
        CloudObject`Private`extra], 
      CloudObject`Private`handleErrorDetails["error-acquiring-kernel", 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "unavailable"], 
        CloudObject`Private`extra], 
      CloudObject`Private`handleErrorDetails["expired", 
        Pattern[CloudObject`Private`extra, {
          Blank[String]}], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := CloudObject`Private`handleArchivedFile[
        First[CloudObject`Private`extra], CloudObject`Private`head], 
      CloudObject`Private`handleErrorDetails[
        Alternatives["no-read-permission", "no-write-permission"], 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "notperm"]], 
      CloudObject`Private`handleErrorDetails[
        Pattern[CloudObject`Private`code, 
         Blank[]], 
        Pattern[CloudObject`Private`extra, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`head, "notparam"]], 
      CloudObject`Private`handleArchivedFile[
        Pattern[CloudObject`Private`uuid, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := If[
        CloudObject`Private`iOSAppQ[], 
        Message[
         MessageName[CloudObject`Private`head, "cloudexpirednourl"]], 
        Message[
         MessageName[CloudObject`Private`head, "cloudarchived"], 
         CloudObject`Private`uuid, CloudObject`Private`upgradeLink]], 
      CloudObject`Private`iOSAppQ[] := (CloudObject`Private`iOSAppQ[] = 
       And[$UserAgentOperatingSystem === "iOS", URLDecode[$UserAgentName] === 
         "Wolfram Cloud"]), CloudObject`Private`processFailureJSONObj[
        Pattern[CloudObject`Private`response, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := 
      With[{CloudObject`Private`failedPropertiesData = 
         CloudObject`Private`getFailedPropertiesData[
          CloudObject`Private`response]}, 
        CloudObject`Private`processFailureForObjProperties[
         First[CloudObject`Private`failedPropertiesData], 
         CloudObject`Private`head]], 
      CloudObject`Private`getFailedPropertiesData[
        Pattern[CloudObject`Private`response, 
         Blank[]]] := 
      Module[{CloudObject`Private`failedPropertiesData, 
         CloudObject`Private`failedProperties}, 
        CloudObject`Private`failedPropertiesData = 
         Map[Lookup[#, {"propertyName", "errorCode", "errorDetails"}]& , 
           Lookup[CloudObject`Private`response, "failures"]]; 
        CloudObject`Private`failedProperties = 
         Map[First, CloudObject`Private`failedPropertiesData]; {
         CloudObject`Private`failedPropertiesData, 
          CloudObject`Private`failedProperties}], 
      CloudObject`Private`processFailureForObjProperties[
        Pattern[CloudObject`Private`failedPropertiesData, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := 
      With[{CloudObject`Private`messages = 
         Map[CloudObject`Private`getMessageTemplate[#, 
            CloudObject`Private`head]& , 
           Part[CloudObject`Private`failedPropertiesData, All, 2]], 
         CloudObject`Private`maxKeyValueLimits = Apply[Last, 
           Part[CloudObject`Private`failedPropertiesData, All, 3], 1]}, 
        MapThread[ReleaseHold[
          Hold[Message][#, #2, #3]]& , {CloudObject`Private`messages, 
          Part[CloudObject`Private`failedPropertiesData, All, 1], 
          CloudObject`Private`maxKeyValueLimits}]], 
      CloudObject`Private`getMessageTemplate["non-empty-directory", 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Hold[
        MessageName[CloudObject`Private`head, "nonempdir"]], 
      CloudObject`Private`getMessageTemplate["overwrite-blocked", 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Hold[
        MessageName[CloudObject`Private`head, "filex"]], 
      CloudObject`Private`getMessageTemplate["fail-to-create-directory", 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Hold[
        MessageName[CloudObject`Private`head, "invcldir"]], 
      CloudObject`Private`getMessageTemplate[
       "property-key-exceeds-size-limit", 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Hold[
        MessageName[CloudObject`Private`head, "propkeylimit"]], 
      CloudObject`Private`getMessageTemplate[
       "property-value-exceeds-size-limit", 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Hold[
        MessageName[CloudObject`Private`head, "propvallimit"]], 
      CloudObject`Private`handleBadObjectUUIDForExecute[
        Pattern[CloudObject`Private`uuid, 
         Blank[]], 
        Pattern[CloudObject`Private`obj, 
         Blank[CloudObject]]] := (
       CloudObject`Private`handleBadObjectUUIDHelper[
        CloudObject`Private`uuid, 
         CloudObject`Private`obj]; {$Failed, $Failed}), 
      CloudObject`Private`handleBadObjectUUIDHelper[
        Pattern[CloudObject`Private`uuid, 
         Blank[]], 
        Pattern[CloudObject`Private`obj, 
         Blank[CloudObject]]] := Switch[CloudObject`Private`uuid, None, 
        Message[
         MessageName[CloudObject, "cloudnf"], 
         CloudObject`Private`obj], $Failed, Null, 
        Blank[], 
        Message[
         MessageName[CloudObject, "srverr"], CloudObject`Private`obj]], 
      CloudObject`Private`getCloudVersionNumber[] := 
      CloudObject`Private`getCloudVersionNumber[$CloudVersionNumber], 
      CloudObject`Private`getCloudVersionNumber[
        Pattern[CloudObject`Private`version, None]] := 
      With[{CloudObject`Private`con = CloudConnect[]}, 
        If[CloudObject`Private`con === $CloudUserID, If[
           Not[
            StringQ[$CloudVersionNumber]], 
           Return[$Failed]]; 
         CloudObject`Private`getCloudVersionNumber[$CloudVersionNumber], 
         Throw[$Failed, CloudObject`Private`FailedToCloudConnect]]], 
      CloudObject`Private`getCloudVersionNumber[
        Pattern[CloudObject`Private`version, 
         Blank[String]]] := (
       CloudObject`Private`getCloudVersionNumber[CloudObject`Private`version] = 
       If[
         CloudObject`Private`versionStringQ[CloudObject`Private`version], 
         CloudObject`Private`normalizeVersionString[
         CloudObject`Private`version], Infinity]), 
      CloudObject`Private`getCloudVersionNumber[
        Pattern[CloudObject`Private`version, 
         Blank[]]] := Infinity, CloudObject`Private`versionStringQ[
        Pattern[CloudObject`Private`version, 
         Blank[]]] := And[
        StringQ[CloudObject`Private`version], 
        StringMatchQ[CloudObject`Private`version, 
         Alternatives[
          Repeated[DigitCharacter], 
          StringExpression[
           Repeated[DigitCharacter], 
           Repeated[
            StringExpression[".", 
             RepeatedNull[DigitCharacter]]]]]]], 
      CloudObject`Private`normalizeVersionString[
        Pattern[CloudObject`Private`version, 
         Blank[String]]] := Interpreter["Number"][
        Replace[
         StringCases[CloudObject`Private`version, NumberString, 1], {
           Pattern[CloudObject`Private`x, 
            Blank[]]} :> CloudObject`Private`x]], 
      CloudObject`Private`handleUsersJSONObject[
        Pattern[CloudObject`Private`userInfo, 
         Blank[List]]] := If[
        KeyExistsQ[CloudObject`Private`userInfo, "users"], 
        Flatten[
         Lookup[CloudObject`Private`userInfo, "users"], 1], 
        CloudObject`Private`userInfo], CloudObject`Private`userFormat[
        Pattern[CloudObject`Private`format, 
         Alternatives[Automatic, "UUID"]]] := 
      Replace[$CloudObjectNameFormat, CloudObject`Private`format -> 
        "UserURLBase"], CloudObject`Private`userFormat[
        Pattern[CloudObject`Private`format, 
         Blank[]]] := CloudObject`Private`format, 
      CloudObject`Private`handleCloudObjectURLType[Automatic, 
        Optional[
         Pattern[CloudObject`Private`msghd, 
          Blank[]], CloudObject]] := 
      CloudObject`Private`handleCloudObjectURLType[$CloudObjectURLType, 
        CloudObject`Private`msghd], 
      CloudObject`Private`handleCloudObjectURLType[
        Pattern[CloudObject`Private`type, 
         Alternatives["Download", "Environment", "Object", "StaticHTML"]], 
        Optional[
         Pattern[CloudObject`Private`msghd, 
          Blank[]], CloudObject]] := 
      Replace[CloudObject`Private`type, 
        CloudObject`Private`$URLTypeConversion], 
      CloudObject`Private`handleCloudObjectURLType[
        Pattern[CloudObject`Private`type, 
         Blank[]], 
        Optional[
         Pattern[CloudObject`Private`msghd, 
          Blank[]], CloudObject]] := (Message[
         MessageName[CloudObject`Private`msghd, "invurltp"], 
         CloudObject`Private`type]; 
       Throw[$Failed, CloudObject`Private`BadOption]), 
      Attributes[$CloudObjectURLType] = {ReadProtected}, 
      CloudObject`Private`$URLTypeConversion := {
       "Download" -> "download", "Environment" -> "env", "Object" -> 
        CloudObject`Private`$objRoot, "StaticHTML" -> "statichtml"}, 
      CloudObject`Private`resolveTimespec[
        Pattern[CloudObject`Private`caller, 
         Blank[]], 
        Pattern[CloudObject`Private`expr, 
         Blank[]]] := With[{CloudObject`Private`cronned = Catch[
           CloudObject`Private`timespec2Cron[CloudObject`Private`expr]]}, 
        If[
         Or[
          FailureQ[CloudObject`Private`cronned], 
          MemberQ[CloudObject`Private`cronned, $Failed, Infinity]], Message[
           MessageName[CloudObject`Private`caller, "sched"], 
           CloudObject`Private`expr]; 
         Throw[$Failed, CloudObject`Private`$tag], 
         CloudObject`Private`cronned]], CloudObject`Private`timespec2Cron[
        Pattern[CloudObject`Private`ts, {
          Blank[DateObject], 
          Alternatives[
           Blank[DateObject], 
           Blank[Integer]]}]] := (Message[
         MessageName[ScheduledTask, "ambig"], CloudObject`Private`ts]; 
       Throw[$Failed, CloudObject`Private`$tag]), 
      CloudObject`Private`timespec2Cron[{
         Pattern[CloudObject`Private`start, 
          Alternatives[
           Blank[DateObject], None, Null]], 
         Pattern[CloudObject`Private`spec, 
          Blank[]]}] := 
      CloudObject`Private`timespec2Cron[{
        CloudObject`Private`start, CloudObject`Private`spec, Null}], 
      CloudObject`Private`timespec2Cron[{
         Pattern[CloudObject`Private`spec, 
          Blank[]], 
         Pattern[CloudObject`Private`end, 
          Alternatives[
           Blank[DateObject], None, Null]]}] := 
      CloudObject`Private`timespec2Cron[{
        Null, CloudObject`Private`spec, CloudObject`Private`end}], 
      CloudObject`Private`timespec2Cron[{
         Pattern[CloudObject`Private`start, 
          Alternatives[
           Blank[DateObject], None, Null]], 
         Pattern[CloudObject`Private`spec, 
          Except[
           Blank[List]]], 
         Pattern[CloudObject`Private`end, 
          Alternatives[
           Blank[DateObject], None, Null]]}] := {CloudObject`Private`start, {
         CloudObject`Private`handleSpec[CloudObject`Private`spec], Infinity}, 
        CloudObject`Private`end}, CloudObject`Private`timespec2Cron[{
         Pattern[CloudObject`Private`start, 
          Alternatives[
           Blank[DateObject], None, Null]], {
          Pattern[CloudObject`Private`spec, 
           Blank[]]}, 
         Pattern[CloudObject`Private`end, 
          Alternatives[
           Blank[DateObject], None, Null]]}] := {CloudObject`Private`start, {
         CloudObject`Private`handleSpec[CloudObject`Private`spec], 1}, 
        CloudObject`Private`end}, CloudObject`Private`timespec2Cron[{
         Pattern[CloudObject`Private`start, 
          Alternatives[
           Blank[DateObject], None, Null]], {
          Pattern[CloudObject`Private`spec, 
           Blank[]], 
          Pattern[CloudObject`Private`rc, 
           Alternatives[
            PatternTest[
             Blank[Integer], Positive], 
            Blank[DirectedInfinity]]]}, 
         Pattern[CloudObject`Private`end, 
          Alternatives[
           Blank[DateObject], None, Null]]}] := {CloudObject`Private`start, {
         CloudObject`Private`handleSpec[CloudObject`Private`spec], 
         CloudObject`Private`rc}, CloudObject`Private`end}, 
      CloudObject`Private`timespec2Cron[
        Pattern[CloudObject`Private`spec, 
         Blank[]]] := 
      CloudObject`Private`timespec2Cron[{
        Null, CloudObject`Private`spec, Null}], 
      CloudObject`Private`timespec2Cron[
        BlankSequence[]] := $Failed, Condition[
        CloudObject`Private`handleSpec[
         Pattern[CloudObject`Private`spec, 
          Blank[String]]], 
        MemberQ[
        CloudObject`Private`$AvailableTimeSpecs, CloudObject`Private`spec]] := 
      ReplaceAll[CloudObject`Private`spec, CloudObject`Private`$TimeSpecs], 
      CloudObject`Private`handleSpec[
        Pattern[CloudObject`Private`spec, 
         Blank[DateObject]]] := 
      With[{CloudObject`Private`cronned = 
         CloudObject`Private`DateObjectToCronSpecification[
          CloudObject`Private`spec]}, 
        CloudObject`Private`handleSpec[CloudObject`Private`cronned]], 
      CloudObject`Private`handleSpec[
        Pattern[CloudObject`Private`spec, 
         Blank[String]]] := 
      With[{CloudObject`Private`cronned = 
         CloudObject`Private`toSchedule[CloudObject`Private`spec]}, 
        If[
         StringQ[CloudObject`Private`cronned], 
         If[
          And[CloudObject`Private`$restrictedScheduler, 
           Not[
            StringMatchQ[CloudObject`Private`cronned, 
             StringExpression["* * ", 
              BlankSequence[]]]]], Message[
            MessageName[ScheduledTask, "rstsch"]]; 
          CloudObject`Private`cronned, 
          CloudObject`Private`cronned], $Failed]], 
      CloudObject`Private`handleSpec[
        HoldPattern[
         Pattern[CloudObject`Private`q, 
          Blank[Quantity]]]] := Module[{CloudObject`Private`res}, 
        If[
         CompatibleUnitQ[CloudObject`Private`q, "Seconds"], 
         CloudObject`Private`res = QuantityMagnitude[
            UnitConvert[CloudObject`Private`q, "Seconds"]]; If[
           And[
           CloudObject`Private`$restrictedScheduler, CloudObject`Private`res < 
            3600], Message[
             MessageName[ScheduledTask, "rstsch"]]; 3600, 
           CloudObject`Private`res], $Failed]], CloudObject`Private`handleSpec[
        PatternTest[
         Pattern[CloudObject`Private`n, 
          Blank[Integer]], Positive]] := If[
        And[
        CloudObject`Private`$restrictedScheduler, CloudObject`Private`n < 
         3600], Message[
          MessageName[ScheduledTask, "rstsch"]]; 3600, CloudObject`Private`n],
       CloudObject`Private`handleSpec[
        Alternatives[None, Null]] := Null, CloudObject`Private`handleSpec[
        BlankSequence[]] := $Failed, 
      CloudObject`Private`$AvailableTimeSpecs = {
       "Hourly", "Daily", "Weekly", "Monthly", "Yearly"}, 
      CloudObject`Private`$TimeSpecs = {"Hourly" :> StringJoin["* ", 
          CloudObject`Private`current[{"MinuteShort"}], " * * * ? *"], 
        "Daily" :> StringJoin["* ", 
          CloudObject`Private`current[{"MinuteShort", " ", "HourShort"}], 
          " * * ? *"], "Weekly" :> StringJoin["* ", 
          CloudObject`Private`current[{"MinuteShort", " ", "HourShort"}], 
          " ? * ", 
          CloudObject`Private`currentDOW[], " *"], "Monthly" :> 
        StringJoin["* ", 
          
          CloudObject`Private`current[{
           "MinuteShort", " ", "HourShort", " ", "DayShort"}], " * ? *"], 
        "Yearly" :> StringJoin["* ", 
          
          CloudObject`Private`current[{
           "MinuteShort", " ", "HourShort", " ", "DayShort", " ", 
            "MonthShort"}], " ? *"]}, CloudObject`Private`current[
        Pattern[CloudObject`Private`spec, 
         Blank[]]] := DateString[
        DateList[], CloudObject`Private`spec], 
      CloudObject`Private`currentDOW[] := 
      With[{CloudObject`Private`date = DateList[]}, 
        Which[
         DayMatchQ[CloudObject`Private`date, Sunday], "1", 
         DayMatchQ[CloudObject`Private`date, Monday], "2", 
         DayMatchQ[CloudObject`Private`date, Tuesday], "3", 
         DayMatchQ[CloudObject`Private`date, Wednesday], "4", 
         DayMatchQ[CloudObject`Private`date, Thursday], "5", 
         DayMatchQ[CloudObject`Private`date, Friday], "6", 
         DayMatchQ[CloudObject`Private`date, Saturday], "7", True, "*"]], 
      CloudObject`Private`DateObjectToCronSpecification[
        HoldPattern[
         Pattern[CloudObject`Private`dObj, 
          PatternTest[
           DateObject[
            Blank[List], 
            TimeObject[
             Pattern[CloudObject`Private`time, 
              Blank[List]], 
             PatternTest[
              BlankNullSequence[], OptionQ]], 
            PatternTest[
             BlankNullSequence[], OptionQ]], DateObjectQ]]], 
        Optional[
         Pattern[CloudObject`Private`target, 
          Blank[]], 1.]] := 
      With[{CloudObject`Private`d = 
         DateAndTime`DateObjectToDateList[
          CloudObject`Private`dObj, CloudObject`Private`target]}, 
        StringJoin[
         Riffle[
          Join[
           Map[ToString[
             Ceiling[#]]& , 
            Reverse[
             Rest[CloudObject`Private`d]]], {"?"}, {
            ToString[
             First[CloudObject`Private`d]]}], " "]]], 
      CloudObject`Private`DateObjectToCronSpecification[
        HoldPattern[
         PatternTest[
          Pattern[CloudObject`Private`dObj, 
           Blank[DateObject]], DateObjectQ]]] := 
      CloudObject`Private`DateObjectToCronSpecification[
       CloudObject`Private`dObj, $TimeZone], 
      CloudObject`Private`DateObjectToCronSpecification[
        HoldPattern[
         PatternTest[
          Pattern[CloudObject`Private`dObj, 
           Blank[DateObject]], DateObjectQ]], 
        Optional[
         Pattern[CloudObject`Private`target, 
          Blank[]], 1.]] := 
      With[{CloudObject`Private`d = 
         DateAndTime`DateObjectToDateList[
          CloudObject`Private`dObj, CloudObject`Private`target]}, 
        StringJoin[
         Riffle[
          Join[
           Reverse[
            Map[ToString[
              Ceiling[#]]& , 
             Rest[CloudObject`Private`d]]], {"?"}, {
            ToString[
             First[CloudObject`Private`d]]}], " "]]], 
      CloudObject`Private`DateObjectToCronSpecification[
        DateObject[
         PatternTest[
          Pattern[CloudObject`Private`l, 
           Blank[]], CloudObject`Private`DatePatternQ]]] := 
      If[0 < Length[CloudObject`Private`l] < 7, 
        Catch[
         With[{
          CloudObject`Private`cron = 
           MapIndexed[
            CloudObject`Private`ElementToCron, CloudObject`Private`l]}, 
          StringJoin[
           Riffle[
            ReplaceAll[
             If[
              FreeQ[CloudObject`Private`cron, CloudObject`Private`DOW], 
              CloudObject`Private`OrderForDOM[CloudObject`Private`cron], 
              CloudObject`Private`OrderForDOW[CloudObject`Private`cron]], {
             CloudObject`Private`DOM[
                Pattern[CloudObject`Private`d, 
                 Blank[]]] :> CloudObject`Private`d, CloudObject`Private`DOW[
                Pattern[CloudObject`Private`d, 
                 Blank[]]] :> CloudObject`Private`d}], " "]]], 
         CloudObject`Private`$tag], $Failed], 
      CloudObject`Private`DateObjectToCronSpecification[
        BlankNullSequence[]] := $Failed, $TimeZone = 1., 
      CloudObject`Private`DatePatternQ[
        Pattern[CloudObject`Private`list, 
         Blank[List]]] := MatchQ[CloudObject`Private`list, {
         Repeated[
          PatternTest[
           Blank[], CloudObject`Private`DatePatternElementQ]]}], 
      CloudObject`Private`DatePatternElementQ[
        PatternTest[
         Blank[], NumberQ]] := True, CloudObject`Private`DatePatternElementQ[
        Verbatim[
         Blank[]]] := True, CloudObject`Private`DatePatternElementQ[
        Pattern[CloudObject`Private`day, 
         Blank[Symbol]]] := 
      MemberQ[CloudObject`Private`$DaysOfTheWeek, CloudObject`Private`day], 
      CloudObject`Private`DatePatternElementQ[
        Verbatim[Alternatives][
         Repeated[
          PatternTest[
           Blank[], CloudObject`Private`DatePatternElementQ]]]] := True, 
      CloudObject`Private`DatePatternElementQ[
        BlankNullSequence[]] := False, 
      CloudObject`Private`$DaysOfTheWeek = {
       Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday}, 
      CloudObject`Private`ElementToCron[
        PatternTest[
         Pattern[CloudObject`Private`element, 
          Blank[]], CloudObject`Private`DatePatternElementQ], 
        Pattern[CloudObject`Private`n, 
         Except[{3}]]] := Which[
        CloudObject`Private`QuartzValueQ[
        CloudObject`Private`element, CloudObject`Private`n], 
        ToString[
         Ceiling[CloudObject`Private`element]], 
        MatchQ[CloudObject`Private`element, 
         Verbatim[
          Blank[]]], "*", 
        MatchQ[CloudObject`Private`element, 
         Verbatim[Alternatives][
          Repeated[
           PatternTest[
            Blank[], 
            CloudObject`Private`QuartzValueQ[#, CloudObject`Private`n]& ]]]], 
        
        StringJoin[
         Riffle[
          Map[ToString[
            Ceiling[#]]& , 
           Apply[List, CloudObject`Private`element]], ","]], True, 
        Throw[$Failed, CloudObject`Private`$tag]], 
      CloudObject`Private`ElementToCron[
        PatternTest[
         Pattern[CloudObject`Private`day, 
          Blank[]], CloudObject`Private`DatePatternElementQ], 
        Pattern[CloudObject`Private`n, {3}]] := Which[
        CloudObject`Private`QuartzValueQ[
        CloudObject`Private`day, CloudObject`Private`n], 
        CloudObject`Private`DOM[
         ToString[
          Ceiling[CloudObject`Private`day]]], 
        MatchQ[CloudObject`Private`day, 
         Verbatim[
          Blank[]]], 
        CloudObject`Private`DOM["*"], 
        MemberQ[CloudObject`Private`$DaysOfTheWeek, 
         Verbatim[CloudObject`Private`day]], 
        CloudObject`Private`DOW[
         ToString[
          First[
           Flatten[
            Position[
            CloudObject`Private`$DaysOfTheWeek, CloudObject`Private`day]]]]], 
        
        MatchQ[CloudObject`Private`day, 
         Verbatim[Alternatives][
          Repeated[
           PatternTest[
            Blank[], MemberQ[CloudObject`Private`$DaysOfTheWeek, #]& ]]]], 
        CloudObject`Private`DOW[
         StringJoin[
          Riffle[
           Map[ToString[
             First[
              Flatten[
               Position[CloudObject`Private`$DaysOfTheWeek, #]]]]& , 
            Apply[List, CloudObject`Private`day]], ","]]], 
        MatchQ[CloudObject`Private`day, 
         Verbatim[Alternatives][
          Repeated[
           PatternTest[
            Blank[], 
            CloudObject`Private`QuartzValueQ[#, CloudObject`Private`n]& ]]]], 
        
        CloudObject`Private`DOM[
         StringJoin[
          Riffle[
           Map[ToString[
             Ceiling[#]]& , 
            Apply[List, CloudObject`Private`day]], ","]]], True, 
        Throw[$Failed, CloudObject`Private`$tag]], 
      CloudObject`Private`ElementToCron[
        BlankNullSequence[]] := Throw[$Failed, CloudObject`Private`$tag], 
      CloudObject`Private`QuartzValueQ[
        Pattern[CloudObject`Private`year, 
         Blank[Integer]], {1}] := 
      TrueQ[1970 <= CloudObject`Private`year <= 2099], 
      CloudObject`Private`QuartzValueQ[
        Pattern[CloudObject`Private`month, 
         Blank[Integer]], {2}] := TrueQ[1 <= CloudObject`Private`month <= 12],
       CloudObject`Private`QuartzValueQ[
        Pattern[CloudObject`Private`dayofmonth, 
         Blank[Integer]], {3}] := 
      TrueQ[1 <= CloudObject`Private`dayofmonth <= 31], 
      CloudObject`Private`QuartzValueQ[
        Pattern[CloudObject`Private`hour, 
         Blank[Integer]], {4}] := TrueQ[0 <= CloudObject`Private`hour <= 23], 
      CloudObject`Private`QuartzValueQ[
        Pattern[CloudObject`Private`minute, 
         Blank[Integer]], {5}] := 
      TrueQ[0 <= CloudObject`Private`minute <= 59], 
      CloudObject`Private`QuartzValueQ[
        Pattern[CloudObject`Private`seconds, 
         Blank[Integer]], {6}] := 
      TrueQ[0 <= CloudObject`Private`seconds <= 59], 
      CloudObject`Private`QuartzValueQ[
        BlankNullSequence[]] := False, CloudObject`Private`OrderForDOM[
        Pattern[CloudObject`Private`list, 
         Blank[List]]] := Insert[
        Reverse[
         CloudObject`Private`PadAppropriately[CloudObject`Private`list]], "?",
         6], CloudObject`Private`PadAppropriately[
        Pattern[CloudObject`Private`list, 
         Blank[List]]] := Join[CloudObject`Private`list, 
        Take[CloudObject`Private`$current, {
          Length[CloudObject`Private`list], -1}]], 
      CloudObject`Private`$current := {
        CloudObject`Private`currentTime["MonthShort"], 
        CloudObject`Private`currentTime["DayShort"], 
        CloudObject`Private`currentTime["HourShort"], 
        CloudObject`Private`currentTime["MinuteShort"], 
        CloudObject`Private`currentTime["SecondShort"]}, 
      CloudObject`Private`currentTime[
        Pattern[CloudObject`Private`spec, 
         Blank[]]] := DateString[
        DateList[], CloudObject`Private`spec], CloudObject`Private`OrderForDOW[
        Pattern[CloudObject`Private`list, 
         Blank[List]]] := Insert[
        Part[
         CloudObject`Private`PadAppropriately[CloudObject`Private`list], {6, 
         5, 4, 2, 3, 1}], "?", 4], CloudObject`Private`toSchedule[
        Pattern[CloudObject`Private`n, 
         Blank[String]]] := 
      Module[{CloudObject`Private`cron}, 
        CloudObject`Private`cron = StringSplit[CloudObject`Private`n]; If[
          Or[
          Length[CloudObject`Private`cron] < 3, 
           Length[CloudObject`Private`cron] > 7], 
          Return[$Failed]]; 
        CloudObject`Private`cron = Replace[CloudObject`Private`cron, {{
              Pattern[CloudObject`Private`s, 
               Blank[]], 
              Pattern[CloudObject`Private`m, 
               Blank[]], 
              Pattern[CloudObject`Private`h, 
               Blank[]], 
              Pattern[CloudObject`Private`dom, 
               Blank[]], 
              Pattern[CloudObject`Private`mo, 
               Blank[]], 
              Pattern[CloudObject`Private`dow, 
               Blank[]], 
              Pattern[CloudObject`Private`y, 
               Blank[]]} :> {
             CloudObject`Private`s, CloudObject`Private`m, 
              CloudObject`Private`h, CloudObject`Private`dom, 
              CloudObject`Private`mo, CloudObject`Private`dow, 
              CloudObject`Private`y}, {
              Pattern[CloudObject`Private`m, 
               Blank[]], 
              Pattern[CloudObject`Private`h, 
               Blank[]], 
              Pattern[CloudObject`Private`dom, 
               Blank[]], 
              Pattern[CloudObject`Private`mo, 
               Blank[]], 
              Pattern[CloudObject`Private`dow, 
               Blank[]], 
              Pattern[CloudObject`Private`y, 
               Blank[]]} :> {
             "*", CloudObject`Private`m, CloudObject`Private`h, 
              CloudObject`Private`dom, CloudObject`Private`mo, 
              CloudObject`Private`dow, CloudObject`Private`y}, {
              Pattern[CloudObject`Private`m, 
               Blank[]], 
              Pattern[CloudObject`Private`h, 
               Blank[]], 
              Pattern[CloudObject`Private`dom, 
               Blank[]], 
              Pattern[CloudObject`Private`mo, 
               Blank[]], 
              Pattern[CloudObject`Private`dow, 
               Blank[]]} :> {
             "*", CloudObject`Private`m, CloudObject`Private`h, 
              CloudObject`Private`dom, CloudObject`Private`mo, 
              CloudObject`Private`dow, "*"}, {
              Pattern[CloudObject`Private`h, 
               Blank[]], 
              Pattern[CloudObject`Private`dom, 
               Blank[]], 
              Pattern[CloudObject`Private`mo, 
               Blank[]], 
              Pattern[CloudObject`Private`dow, 
               Blank[]]} :> {
             "*", "*", CloudObject`Private`h, CloudObject`Private`dom, 
              CloudObject`Private`mo, CloudObject`Private`dow, "*"}}]; 
        StringJoin[
          Riffle[
           ToUpperCase[CloudObject`Private`cron], " "]]], 
      CloudObject`Private`toSchedule[
        BlankNullSequence[]] := $Failed, 
      CloudObject`Private`$restrictedScheduler := 
      CloudEvaluate[CloudSystem`Scheduling`$restricted], 
      Attributes[CloudObject`Private`nowQ] = {HoldAll}, 
      CloudObject`Private`nowQ[Now] := True, CloudObject`Private`nowQ[{Now}] := 
      True, CloudObject`Private`nowQ[{Now, 
         Pattern[CloudObject`Private`end, 
          Blank[DateObject]]}] := MatchQ[
        ReleaseHold[CloudObject`Private`end], 
        Blank[DateObject]], CloudObject`Private`nowQ[{Now, 
         Pattern[CloudObject`Private`count, 
          Blank[]]}] := MatchQ[
        ReleaseHold[CloudObject`Private`count], 
        Alternatives[
         Blank[Integer], Infinity, DirectedInfinity]], 
      CloudObject`Private`nowQ[{
         Pattern[CloudObject`Private`start, 
          Blank[]], Now, 
         Pattern[CloudObject`Private`end, 
          Blank[]]}] := And[
        MatchQ[
         ReleaseHold[CloudObject`Private`start], 
         Blank[DateObject]], 
        MatchQ[
         ReleaseHold[CloudObject`Private`end], 
         Blank[DateObject]]], CloudObject`Private`nowQ[{
         Pattern[CloudObject`Private`start, 
          Blank[DateObject]], Now}] := MatchQ[
        ReleaseHold[CloudObject`Private`start], 
        Blank[DateObject]], CloudObject`Private`nowQ[
        BlankNullSequence[]] := False, CloudObject`Private`generateTaskJson[
        ScheduledTask[
         Pattern[CloudObject`Private`f, 
          Blank[File]], 
         Pattern[CloudObject`Private`rest, 
          BlankSequence[]]], 
        Pattern[CloudObject`Private`more, 
         BlankSequence[]]] := 
      With[{CloudObject`Private`package = CloudExport[
           Import[CloudObject`Private`f, "String"], "String"]}, 
        CloudObject`Private`generateTaskJson[
         ScheduledTask[
          CloudGet[CloudObject`Private`package], CloudObject`Private`rest], 
         CloudObject`Private`more]], CloudObject`Private`generateTaskJson[
        ScheduledTask[
         Pattern[CloudObject`Private`co, 
          Blank[CloudObject]], 
         Pattern[CloudObject`Private`rest, 
          BlankSequence[]]], 
        Pattern[CloudObject`Private`more, 
         BlankSequence[]]] := CloudObject`Private`generateTaskJson[
        ScheduledTask[
         CloudGet[CloudObject`Private`co], CloudObject`Private`rest], 
        CloudObject`Private`more], CloudObject`Private`generateTaskJson[
        Pattern[CloudObject`Private`st, 
         ScheduledTask[
          Pattern[CloudObject`Private`expr, 
           Blank[]], 
          BlankSequence[]]], {
         Pattern[CloudObject`Private`name, 
          Alternatives[
           Blank[String], Null]], 
         Pattern[CloudObject`Private`uuid, 
          Alternatives[
           Blank[String], Null]]}, {
         Pattern[CloudObject`Private`start, 
          Blank[]], 
         Pattern[CloudObject`Private`stdSched, 
          Blank[]], 
         Pattern[CloudObject`Private`end, 
          Blank[]]}, 
        Pattern[CloudObject`Private`o, {
          PatternTest[
           BlankNullSequence[], OptionQ]}], 
        Pattern[CloudObject`Private`deploymentOptions, {
          PatternTest[
           BlankNullSequence[], OptionQ]}]] := 
      Module[{CloudObject`Private`opts, CloudObject`Private`cont, 
         CloudObject`Private`type = "co", CloudObject`Private`strexpr, 
         CloudObject`Private`result, CloudObject`Private`startTimestamp, 
         CloudObject`Private`endTimestamp, CloudObject`Private`content}, 
        CloudObject`Private`cont = 
         Lookup[CloudObject`Private`o, "Continuous", False]; If[
          TrueQ[
           KeyMemberQ[CloudObject`Private`o, NotificationFunction]], 
          CloudObject`Private`opts = Normal[
            MapAt[CloudObject`Private`verboseNotificationFunctionformat, 
             Apply[Association, CloudObject`Private`o], 
             Key[NotificationFunction]]], 
          CloudObject`Private`opts = CloudObject`Private`o; Null]; 
        CloudObject`Private`opts = 
         CloudObject`Private`formatTaskOptions[
          CloudObject`Private`opts, ScheduledTask]; If[
          Not[
           BooleanQ[
            Lookup[
            CloudObject`Private`deploymentOptions, IncludeDefinitions]]], 
          Message[
            MessageName[General, "invincludedf"], 
            Lookup[
            CloudObject`Private`deploymentOptions, IncludeDefinitions]]; 
          Return[$Failed]; Null]; 
        CloudObject`Private`content = CloudObject`Private`exprToPortableString[
           Unevaluated[CloudObject`Private`expr]]; 
        CloudObject`Private`strexpr = CloudObject`Private`exportToJSON[{
            CloudObject`Private`exprDefinitionsToString[
             Unevaluated[CloudObject`Private`expr], 
             Quiet[
              Lookup[
              CloudObject`Private`deploymentOptions, IncludeDefinitions, 
               True]]], 
            If[CloudObject`Private`cont, "ContinuousTask", "ScheduledTask"], 
            CloudObject`Private`content, 
            Apply[Sequence, 
             Map[ToString[#, InputForm]& , 
              DeleteCases[
               FilterRules[CloudObject`Private`opts, 
                Options[ScheduledTask]], "RunImmediately" -> Blank[]]]]}, 
           "Compact" -> True]; 
        CloudObject`Private`startTimestamp = 
         Replace[CloudObject`Private`start, {Pattern[CloudObject`Private`d, 
              Blank[DateObject]] :> 1000 UnixTime[CloudObject`Private`d]}]; 
        CloudObject`Private`endTimestamp = 
         Replace[CloudObject`Private`end, {Pattern[CloudObject`Private`d, 
              Blank[DateObject]] :> 1000 UnixTime[CloudObject`Private`d]}]; 
        CloudObject`Private`result = {
          "type" -> If[
            CloudObject`Private`cont, "cont", CloudObject`Private`type], 
           "userId" -> $CloudUserUUID, "uuid" -> CloudObject`Private`uuid, 
           "jobType" -> 
           If[CloudObject`Private`cont, "cont", CloudObject`Private`type], 
           "continuous" -> CloudObject`Private`cont, "visible" -> 
           Lookup[CloudObject`Private`opts, "Visible", True], 
           "startTimestamp" -> CloudObject`Private`startTimestamp, 
           "endTimestamp" -> CloudObject`Private`endTimestamp, "timeZone" -> 
           Lookup[CloudObject`Private`opts, TimeZone], "count" -> 
           If[Length[CloudObject`Private`stdSched] > 1, 
             ToString[
              Part[CloudObject`Private`stdSched, -1]], "Infinity"], 
           "repeatCount" -> ToString[
             Part[CloudObject`Private`stdSched, -1]], "interval" -> If[
             TrueQ[Head[
                Part[CloudObject`Private`stdSched, 1]] == String], "", 
             Part[CloudObject`Private`stdSched, 1]], "notificatees" -> 
           CloudObject`Private`exportToJSON[
             CloudObject`Private`denormalizeNotificationFunction[
              Lookup[CloudObject`Private`opts, NotificationFunction]], 
             "Compact" -> True], "cron" -> If[
             StringQ[
              Part[CloudObject`Private`stdSched, 1]], 
             Part[CloudObject`Private`stdSched, 1], ""], "runImmediately" -> 
           Lookup[CloudObject`Private`opts, "RunImmediately", False], "name" -> 
           CloudObject`Private`name, "expression" -> 
           CloudObject`Private`strexpr}], CloudObject`Private`generateTaskJson[
        Pattern[CloudObject`Private`ar, 
         AutoRefreshed[
          Pattern[CloudObject`Private`expr, 
           Blank[]], 
          Blank[], 
          Pattern[CloudObject`Private`fmt, 
           Blank[]], 
          BlankNullSequence[]]], {
         Pattern[CloudObject`Private`name, 
          Alternatives[
           Blank[String], Null]], 
         Pattern[CloudObject`Private`uuid, 
          Alternatives[
           Blank[String], Null]]}, {
         Pattern[CloudObject`Private`start, 
          Blank[]], 
         Pattern[CloudObject`Private`stdSched, 
          Blank[]], 
         Pattern[CloudObject`Private`end, 
          Blank[]]}, 
        Pattern[CloudObject`Private`o, {
          PatternTest[
           BlankNullSequence[], OptionQ]}], 
        Pattern[CloudObject`Private`deploymentOptions, {
          PatternTest[
           BlankNullSequence[], OptionQ]}]] := 
      Module[{CloudObject`Private`opts, CloudObject`Private`cont, 
         CloudObject`Private`type, CloudObject`Private`strexpr, 
         CloudObject`Private`result, CloudObject`Private`startTimestamp, 
         CloudObject`Private`endTimestamp, CloudObject`Private`content}, 
        CloudObject`Private`cont = 
         Lookup[CloudObject`Private`o, "Continuous", False]; If[
          TrueQ[
           KeyMemberQ[CloudObject`Private`o, NotificationFunction]], 
          CloudObject`Private`opts = Normal[
            MapAt[CloudObject`Private`verboseNotificationFunctionformat, 
             Apply[Association, CloudObject`Private`o], 
             Key[NotificationFunction]]], 
          CloudObject`Private`opts = CloudObject`Private`o; Null]; 
        CloudObject`Private`opts = 
         CloudObject`Private`formatTaskOptions[
          CloudObject`Private`opts, AutoRefreshed]; 
        CloudObject`Private`content = CloudObject`Private`exprToPortableString[
           Unevaluated[CloudObject`Private`expr]]; 
        CloudObject`Private`type = "ar"; 
        CloudObject`Private`strexpr = CloudObject`Private`exportToJSON[{
            CloudObject`Private`exprDefinitionsToString[
             Unevaluated[CloudObject`Private`expr], 
             Quiet[
              Lookup[
              CloudObject`Private`deploymentOptions, IncludeDefinitions, 
               True]]], "AutoRefreshed", CloudObject`Private`content, 
            StringJoin["\"", CloudObject`Private`fmt, "\""], 
            Apply[Sequence, 
             Map[ToString[#, InputForm]& , 
              DeleteCases[
              CloudObject`Private`opts, 
               Alternatives["RunImmediately", "Visible"] -> Blank[]]]]}, 
           "Compact" -> True]; 
        CloudObject`Private`startTimestamp = 
         Replace[CloudObject`Private`start, {Pattern[CloudObject`Private`d, 
              Blank[DateObject]] :> 1000 UnixTime[CloudObject`Private`d]}]; 
        CloudObject`Private`endTimestamp = 
         Replace[CloudObject`Private`end, {Pattern[CloudObject`Private`d, 
              Blank[DateObject]] :> 1000 UnixTime[CloudObject`Private`d]}]; 
        CloudObject`Private`result = {
          "type" -> CloudObject`Private`type, "userId" -> $CloudUserUUID, 
           "uuid" -> CloudObject`Private`uuid, "jobType" -> 
           CloudObject`Private`type, "continuous" -> CloudObject`Private`cont,
            "visible" -> Lookup[CloudObject`Private`opts, "Visible", True], 
           "startTimestamp" -> CloudObject`Private`startTimestamp, 
           "endTimestamp" -> CloudObject`Private`endTimestamp, "timeZone" -> 
           Lookup[CloudObject`Private`opts, TimeZone], "count" -> 
           If[Length[CloudObject`Private`stdSched] > 1, 
             ToString[
              Part[CloudObject`Private`stdSched, -1]], "Infinity"], 
           "repeatCount" -> ToString[
             Part[CloudObject`Private`stdSched, -1]], "interval" -> If[
             TrueQ[Head[
                Part[CloudObject`Private`stdSched, 1]] == String], "", 
             Part[CloudObject`Private`stdSched, 1]], "notificatees" -> 
           CloudObject`Private`exportToJSON[
             CloudObject`Private`denormalizeNotificationFunction[
              Lookup[CloudObject`Private`opts, NotificationFunction]], 
             "Compact" -> True], "cron" -> If[
             StringQ[
              Part[CloudObject`Private`stdSched, 1]], 
             Part[CloudObject`Private`stdSched, 1], ""], "runImmediately" -> 
           False, "name" -> CloudObject`Private`name, "expression" -> 
           CloudObject`Private`strexpr}], 
      CloudObject`Private`verboseNotificationFunctionformat[
        Pattern[CloudObject`Private`nf, 
         Blank[]]] := 
      Replace[CloudObject`Private`nf, {
        Alternatives[Null, None] -> {}, All -> {{$CloudUserID} -> All}, 
         Automatic -> {{$CloudUserID} -> Automatic}, 
         Pattern[CloudObject`Private`f, 
           Blank[Function]] :> {{$CloudUserID} -> CloudObject`Private`f}, {
           Pattern[CloudObject`Private`u, 
            BlankSequence[String]]} :> {{CloudObject`Private`u} -> 
           Automatic}, (Pattern[CloudObject`Private`s, 
            Blank[String]] -> Pattern[CloudObject`Private`cond, 
            Alternatives[Automatic, All]]) :> {{$CloudUserID} -> {
            CloudObject`Private`s, CloudObject`Private`cond}}}], 
      CloudObject`Private`formatTaskOptions[
        Pattern[CloudObject`Private`opts, 
         Blank[]], 
        Pattern[CloudObject`Private`head, 
         Blank[]]] := Replace[
        DeleteDuplicatesBy[
         Join[CloudObject`Private`opts, 
          Options[CloudObject`Private`head]], 
         First], {(TimeZone -> Automatic) :> (TimeZone -> $TimeZone), (
          TimeZone -> Pattern[CloudObject`Private`id, 
            Blank[String]]) :> 
         With[{CloudObject`Private`tz = 
            Entity["TimeZone", CloudObject`Private`id]}, TimeZone -> 
           QuantityMagnitude[
             CloudObject`Private`tz["OffsetFromUTC"], "Hours"]], (TimeZone -> 
          Pattern[CloudObject`Private`tz, 
            Entity["TimeZone", 
             Blank[String]]]) :> (TimeZone -> QuantityMagnitude[
            CloudObject`Private`tz["OffsetFromUTC"], "Hours"]), (TimeZone -> 
          PatternTest[
            Pattern[CloudObject`Private`tz, 
             Blank[]], NumberQ]) :> (TimeZone -> CloudObject`Private`tz), (
          TimeZone -> Blank[]) :> (TimeZone -> $TimeZone)}, 1], 
      CloudObject`Private`exprToPortableString[
        Pattern[CloudObject`Private`expr, 
         Blank[]]] := CloudObject`Private`neutralContextBlock[
        CloudObject`Private`toPrintableString[
         Unevaluated[CloudObject`Private`expr]]], 
      Attributes[CloudObject`Private`neutralContextBlock] = {HoldFirst}, 
      CloudObject`Private`neutralContextBlock[
        Pattern[CloudObject`Private`expr, 
         Blank[]]] := 
      Block[{$ContextPath = {"System`"}, $Context = "System`"}, 
        CloudObject`Private`expr], $ContextPath = {
       "Global`", "System`"}, $Context = "Global`", 
      CloudObject`Private`toPrintableString[
        Pattern[CloudObject`Private`expr, 
         Blank[]]] := Module[{CloudObject`Private`result = ToString[
           Unevaluated[CloudObject`Private`expr], InputForm, 
           CharacterEncoding -> "PrintableASCII"]}, 
        If[
         PrintableASCIIQ[CloudObject`Private`result], 
         CloudObject`Private`result, 
         ToString[
          Unevaluated[CloudObject`Private`expr], InputForm, CharacterEncoding -> 
          "ISO8859-1"]]], CloudObject`Private`exportToJSON[
        Pattern[CloudObject`Private`list$, {
          BlankSequence[Rule]}], 
        Pattern[CloudObject`Private`opts$, 
         BlankNullSequence[]]] := Developer`ToJSON[
        Apply[Association, CloudObject`Private`list$], 
        CloudObject`Private`opts$], CloudObject`Private`exportToJSON[
        Pattern[CloudObject`Private`x$, 
         Blank[]], 
        Pattern[CloudObject`Private`opts$, 
         BlankNullSequence[]]] := 
      Developer`ToJSON[CloudObject`Private`x$, CloudObject`Private`opts$], 
      Attributes[CloudObject`Private`list$] = {Temporary}, 
      Attributes[CloudObject`Private`opts$] = {Temporary}, Developer`ToJSON[
        Pattern[System`Private`expr, 
         Blank[]], 
        Pattern[System`Private`opts, 
         OptionsPattern[]]] := 
      Developer`WriteRawJSONString[
       System`Private`expr, "JSONObjectAsList" -> True, "PrecisionHandling" -> 
        "Coerce", "IssueMessagesAs" -> Developer`ToJSON, System`Private`opts],
       Options[Developer`ToJSON] = {
       "Compact" -> False, "ConversionFunction" -> None, 
        "ConversionRules" -> {}}, 
      Attributes[CloudObject`Private`x$] = {Temporary}, 
      CloudObject`Private`exprDefinitionsToString[
        Pattern[CloudObject`Private`expr, 
         Blank[]], True] := CloudObject`Private`exprToStringDefinitions[
        Unevaluated[CloudObject`Private`expr]], 
      CloudObject`Private`exprDefinitionsToString[
        Pattern[CloudObject`Private`expr, 
         Blank[]], 
        Blank[]] := "", CloudObject`Private`exprToStringDefinitions[
        Pattern[CloudObject`Private`expr, 
         Blank[]]] := 
      With[{CloudObject`Private`defs = 
         CloudObject`Private`getDefinitionsList[
           Unevaluated[CloudObject`Private`expr]]}, 
        If[CloudObject`Private`defs === Language`DefinitionList[], "", 
         StringJoin[
          CloudObject`Private`neutralContextBlock[
           With[{CloudObject`Private`d = CloudObject`Private`defs}, 
            CloudObject`Private`toPrintableString[
             Unevaluated[
             Language`ExtendedFullDefinition[] = CloudObject`Private`d]]]], 
          ";\n\n"]]], CloudObject`Private`getDefinitionsList[
        Pattern[CloudObject`Private`expr, 
         Blank[]]] := With[{CloudObject`Private`excl = Join[
           OptionValue[Language`ExtendedFullDefinition, "ExcludedContexts"], 
           CloudObject`Private`$ExcludeContexts]}, 
        Language`ExtendedFullDefinition[
        CloudObject`Private`expr, "ExcludedContexts" -> 
         Complement[
          CloudObject`Private`excl, CloudObject`Private`$IncludedContexts]]], 
      Attributes[Language`ExtendedFullDefinition] = {HoldFirst}, 
      Options[Language`ExtendedFullDefinition] := {
       "ExcludedContexts" -> {
         "Algebra", "Algebraics", "AlphaIntegration", "Annotation", 
          "Annotations", "Association", "Assumptions", "AssumptionsDump", 
          "Asymptotics", "Audio", "AudioTools", "AugmentedData", 
          "Authentication", "BinningUtilities", "Blockchain", 
          "BooleanAlgebra", "BoxForm", "BoxFormat", "BrowserCategoryLoad", 
          "Calendar", "CCodeGenerator", "CCompilerDriver", "Charting", 
          "Chemistry", "CloudDialogs", "CloudExpression", "CloudObject", 
          "CloudSystem", "ClusterAnalysis", "Compile", "CompileDefinition", 
          "CompiledLibrary", "Compiler", "CompileUtilities", 
          "ComplexAnalysis", "ComputationalGeometry", "Conditional", 
          "Control", "ControlSystems", "Conversion", "Convert", 
          "Cryptography", "CUDAInformation", "CURLLink", "Data", 
          "DatabaseLink", "DataDropClient", "DataPaclets", "Dataset", 
          "DataStructure", "DateAndTime", "Debug", "Debugger", "Deconvolve", 
          "Developer", "DeviceFramework", "Devices", "Discrete", 
          "DiscreteMath", "Documentation", "DocumentationSearch", 
          "DragAndDrop", "DrawPolarAxes", "DSolve", "DynamicDump", 
          "DynamicGeoGraphics", "Embedded", "EntityFramework", 
          "EquationalLogic", "EquationalProof", "Experimental", "Explore", 
          "ExternalEvaluate", "ExternalService", "ExternalStorage", "Extras", 
          "Factor", "FE", "FEPrivate", "FFmpegTools", "FileFormatDump", 
          "Finance", "FindCharacterEncoding", "FindMinimum", "FindRoot", 
          "FittedModels", "Format", "FormulaData", "FrontEnd", 
          "FunctionProperties", "GeneralUtilities", "GenerateConditions", 
          "GeoGraphics", "GeometricFunctions", "Geometry", "GIFTools", "GIS", 
          "GraphComputation", "Graphics", "GraphicsArray", "GraphicsGrid", 
          "GroebnerBasis", "GroebnerGCD", "GroupTheory", 
          "HierarchicalClustering", "Histogram", "Holonomic", "HTTPHandling", 
          "HypergeometricLogDump", "Iconize", "ICULink", "ILD", "Image", 
          "ImageAcquisition", "ImageTransformation", "IMAPLink", "IMAQ", 
          "ImportExport", "Information", "Inpaint", "InputAssistant", 
          "Integrate", "IntegratedServices", "InteractiveGraphics", 
          "Internal", "Interpreter", "JLink", "JSONTools", "Language", 
          "Legending", "LibraryLink", "Limit", "LinearAlgebra", 
          "LocalObjects", "MailLink", "Manipulate", "MarkovProcesses", 
          "MathLink", "MatrixFunction", "MatrixLog", "MatrixPower", 
          "MatrixSqrt", "MediaTools", "MessageMenu", "Method", "MLFS", 
          "MobileMessaging", "MultivariateResultant", "MUnit", 
          "NaturalLanguage", "NDSolve", "NETLink", "Network", 
          "NeuralNetworks", "NIntegrate", "NMinimize", 
          "NotebookCompatibility", "NotebookTemplating", "NotebookTools", 
          "NProduct", "NRoots", "NSolve", "NSum", "NumberNameDump", 
          "NumberTheory", "NumericalMath", "NumericArray", 
          "OpenCLInformation", "Optimization", "OutputSizeLimit", "Package", 
          "PacletManager", "PacletTools", "Parallel", "Periodic", 
          "PersistenceLocations", "PlaneGeometry", "PlanetaryAstronomy", 
          "Predictions", "PredictiveInterface", "Product", "Progress", 
          "QuadraticOptimization", "Quantifier", "QuantityArray", 
          "QuantityUnits", "Random", "RandomProcesses", "Reduce", "Region", 
          "RegularChains", "Reliability", "ResourceFunctionHelpers", 
          "ResourceLocator", "ResourceSystemClient", "RomanNumerals", 
          "RootReduce", "RootsDump", "RSolve", "RuntimeTools", 
          "SecureShellLink", "Semantic", "Series", "Services", "Signal", 
          "SimilarityScoreMatrices", "Simplify", "Socket", "Solve", "Sound", 
          "SparseArray", "SpecialFunctions", "StartUp", "Statistics", 
          "StochasticCalculus", "Stream", "Streaming", "StringPattern", 
          "StructuredArray", "StructureDetection", "StyleManager", 
          "SubKernels", "Sum", "SurfaceGraphics", "SymbolicTensors", "System",
           "SystemTools", "Tasks", "Templating", "TemporalData", 
          "TemporalDataUtilities", "TextProcessing", "Themes", "Transforms", 
          "Typeset", "Uncertainty", "URLUtilities", "Utilities", "ValueTrack",
           "Video", "Visualization", "Wavelets", "WebServices", "WSTP", 
          "XML"}, "IssueReadProtectedMessages" -> False}, 
      CloudObject`Private`$ExcludeContexts = {
       "MailReceiver", "CloudSystem", "Forms", "Templating", "Interpreter", 
        "CloudObject", "RLink"}, CloudObject`Private`$IncludedContexts = {}, 
      Attributes[Language`DefinitionList] = {HoldAll}, 
      CloudObject`Private`denormalizeNotificationFunction[
        Pattern[CloudObject`Private`notifRaw, 
         Blank[]]] := 
      Module[{CloudObject`Private`notif = 
         Replace[CloudObject`Private`notifRaw, {
           Alternatives[Null, None] -> {}, All -> {{$CloudUserID} -> All}, 
            Automatic -> {{$CloudUserID} -> Automatic}, 
            Pattern[CloudObject`Private`f, 
              Blank[Function]] :> {{$CloudUserID} -> CloudObject`Private`f}, {
             
              Pattern[CloudObject`Private`u, 
               BlankSequence[String]]} :> {{CloudObject`Private`u} -> 
              Automatic}, (Pattern[CloudObject`Private`s, 
               Blank[String]] -> Pattern[CloudObject`Private`cond, 
               Alternatives[Automatic, All]]) :> {{$CloudUserID} -> {
               CloudObject`Private`s, CloudObject`Private`cond}}}]}, 
        CloudObject`Private`notif = 
         Replace[CloudObject`Private`notif, (Pattern[CloudObject`Private`addr, 
              Blank[]] -> Pattern[CloudObject`Private`cond, 
              Blank[]]) :> (Flatten[{CloudObject`Private`addr}] -> 
            Replace[CloudObject`Private`cond, {
              None -> Null, Pattern[CloudObject`Private`ns, 
                 Except[
                  Blank[String]]] :> ToString[
                 InputForm[CloudObject`Private`ns]]}]), {1}]; 
        With[{CloudObject`Private`pairs = DeleteDuplicates[
             Flatten[
              Map[Thread[
                Apply[List, #], List, 1]& , CloudObject`Private`notif], 1]]}, 
          
          
          Map[{"email" -> First[#], "condition" -> Last[#]}& , 
           CloudObject`Private`pairs]]], CloudObject`Private`scheduledTaskQ[
        Pattern[CloudObject`Private`co, 
         Blank[CloudObject]]] := With[{CloudObject`Private`mime = Quiet[
           Check[
            CloudObjectInformation[
            CloudObject`Private`co, "MIMEType"], $Failed]]}, 
        MemberQ[
        CloudObject`Private`$taskMimeTypes, CloudObject`Private`mime]], 
      CloudObject`Private`scheduledTaskQ[
        Blank[]] := False, 
      CloudObject`Private`$taskMimeTypes = {
       "application/vnd.wolfram.expression.task"}, 
      CloudObject`Private`safeCloudAndUUIDFetch[
        CloudObject`Private`deleteable[
         Pattern[CloudObject`Private`obj, 
          Blank[CloudObject]]], 
        Optional[
         Pattern[CloudObject`Private`mh, 
          Blank[]], ScheduledTask]] := 
      CloudObject`Private`safeCloudAndUUIDFetch[
       CloudObject`Private`obj, CloudObject`Private`mh], 
      CloudObject`Private`safeCloudAndUUIDFetch[
        CloudObject`Private`preexisting[
         Pattern[CloudObject`Private`obj, 
          Blank[CloudObject]]], 
        Optional[
         Pattern[CloudObject`Private`mh, 
          Blank[]], ScheduledTask]] := 
      CloudObject`Private`safeCloudAndUUIDFetch[
       CloudObject`Private`obj, CloudObject`Private`mh], 
      CloudObject`Private`safeCloudAndUUIDFetch[
        Pattern[CloudObject`Private`obj, 
         Blank[CloudObject]], 
        Optional[
         Pattern[CloudObject`Private`mh, 
          Blank[]], ScheduledTask]] := Replace[
        CloudObject`Private`getCloudAndUUID[CloudObject`Private`obj], {{
           Blank[], None} :> (Message[
            MessageName[CloudObject`Private`mh, "cloudnf"], 
            CloudObject`Private`obj]; 
          Throw[$Failed, CloudObject`Private`$tag])}], 
      CloudObject`Private`safeCloudAndUUIDFetch[None, 
        Pattern[CloudObject`Private`mh, 
         Blank[]]] := {$CloudBase, Null}, 
      CloudObject`Private`safeCloudAndUUIDFetch[
        BlankNullSequence[]] := Throw[$Failed, CloudObject`Private`$tag], 
      CloudObject`Private`handleTaskErrorMessage[
        Pattern[CloudObject`Private`error, 
         Blank[String]], 
        Pattern[CloudObject`Private`mh, 
         Blank[]]] := If[
        StringMatchQ[CloudObject`Private`error, 
         StringExpression[
          Alternatives["ContinuousTask", "ScheduledTask"], "::", 
          Repeated[WordCharacter]]], 
        ToExpression[CloudObject`Private`error, InputForm, Message], 
        Message[
         MessageName[CloudObject`Private`mh, "argu"]]], 
      CloudObject`Private`handleTaskErrorMessage[
        Blank[], 
        Pattern[CloudObject`Private`mh, 
         Blank[]]] := Message[
        MessageName[CloudObject`Private`mh, "argu"]], G10400601`pokazZaDuzoCDF[
        Pattern[$CellContext`wymiary, 
         Blank[]]] := (G10400601`ramkaNaStartStop[#, $CellContext`wymiary]& )[{
         (Style[#, FontFamily -> "Arial", 14]& )[
         "\[CapitalCAcute]wiczenie nie mo\:017ce by\[CAcute] uruchomione."], 
         (Style[#, FontFamily -> "Arial", 12]& )[
         "Licencja pozwala uruchomi\[CAcute] tylko jedno w danej chwili."], 
         (Style[#, FontFamily -> "Arial", 12]& )[
         "Zamknij otwarte \[CAcute]wiczenie i spr\[OAcute]buj ponownie."], 
         G10400601`GButton[
          Style[
          "Zamknij", 12, $CellContext`KolorPodstawowyJasny, Bold, FontFamily -> 
           "Arial"], 
          NotebookClose[], ImageSize -> {100, 30}, G10400601`BaseColor -> 
          Darker[$CellContext`KolorPodstawowy]]}], G10400601`pokazKoniec[
        Pattern[$CellContext`wymiary, 
         Blank[]]] := (G10400601`ramkaNaStartStop[#, $CellContext`wymiary]& )[{
         (Style[#, FontFamily -> "Arial", 14]& )[
         "Up\[LSlash]yn\:0105\[LSlash] czas pracy \[CAcute]wiczenia."], 
         (Style[#, FontFamily -> "Arial", 12]& )[
         "Skontaktuje si\:0119 z nami, aby si\:0119 dowiedzie\[CAcute],"], 
         (Style[#, FontFamily -> "Arial", 12]& )[
         "jak usun\:0105\[CAcute] ograniczenie czasowe:"], 
         (Style[#, FontFamily -> "Arial", 12]& )[
         "matematykawszkole@gambit.net.pl"], 
         G10400601`GButton[
          Style[
          "Zamknij", 12, $CellContext`KolorPodstawowyJasny, Bold, FontFamily -> 
           "Arial"], 
          NotebookClose[], ImageSize -> {100, 30}, G10400601`BaseColor -> 
          Darker[$CellContext`KolorPodstawowy]]}], 
      G10400601`pokazBrakDostepu[
        Pattern[$CellContext`wymiary, 
         Blank[]]] := (G10400601`ramkaNaStartStop[#, $CellContext`wymiary]& )[
       
        If[G10400601`ktoraProbaLaczenia > 3, {
          (Style[#, 14, FontFamily -> "Arial"]& )[
          "Brak dost\:0119pu do portalu"], 
          (Style[#, 12, FontFamily -> "Arial"]& )[
          "Sprawd\:017a po\[LSlash]\:0105czenie internetowe"], 
          Button[
           (Style[#, 14, 
            $CellContext`paletaKolorow[1], Bold, FontFamily -> "Arial"]& )[
           "Zamknij"], 
           NotebookClose[], Method -> "Queued", Appearance -> "DialogBox", 
           Background -> $CellContext`paletaKolorow[0.4], 
           ImageSize -> {165, 30}]}, {
          (Style[#, 14, FontFamily -> "Arial"]& )[
          "Brak dost\:0119pu do portalu"], 
          (Style[#, 12, FontFamily -> "Arial"]& )[
          "Spr\[OAcute]buj jeszcze raz"], 
          Button[
           (Style[#, 14, 
            $CellContext`paletaKolorow[1], Bold, FontFamily -> "Arial"]& )[
           "Spr\[OAcute]buj ponownie"], G10400601`wiatrak = False; 
           G10400601`warstwa = "Nic", Method -> "Queued", Appearance -> 
           "DialogBox", Background -> $CellContext`paletaKolorow[0.4], 
           ImageSize -> {165, 30}]}]], G10400601`pokazPrzerwa[
        Pattern[$CellContext`wymiary, 
         Blank[]]] := (G10400601`ramkaNaStartStop[#, $CellContext`wymiary]& )[{
         (Style[#, 14, FontFamily -> "Arial"]& )["Przerwa techniczna"], 
         (Style[#, 12, FontFamily -> "Arial"]& )[
         "Trwaj\:0105 zaplanowane prace serwisowe"], 
         (Style[#, 12, FontFamily -> "Arial"]& )[
         "Dost\:0119p b\:0119dzie wznowiony"], 
         (Style[#, 12, FontFamily -> "Arial"]& )[
         G10400601`przerwaDoKiedyText], 
         Button[
          (Style[#, 14, 
           $CellContext`paletaKolorow[1], Bold, FontFamily -> "Arial"]& )[
          "Zamknij"], 
          NotebookClose[], Method -> "Queued", Appearance -> "DialogBox", 
          Background -> $CellContext`paletaKolorow[0.4], 
          ImageSize -> {165, 30}]}], G10400601`przerwaDoKiedyText := 
      StringJoin[
       "w dniu: ", G10400601`parBazyPDoD, " o godz: ", G10400601`parBazyPDoG],
       G10400601`kropki[] := 
      Switch[G10400601`typDostepu, 2, ".", 3, ",", 1, "", 
        Blank[], ";"]}; (Needs["DatabaseLink`"]; G10400601`baza = {}; 
     G10400601`czyJestPolaczenie = False; 
     G10400601`dataWL = 
      DateObject["2020-12-31"]; {
       G10400601`ad, G10400601`un, G10400601`ub, G10400601`ps, G10400601`pb} = 
      Uncompress[
       "1:eJxTTMoPSmNlYGAoZgESPpnFJcHKQEZ5ebleemJuUmaJXl5qiV5Bjj6EF5+\
bWJIKxJXZicEcQHWhxalFeYm5qcHsQE5ySlopkA+\
WCEgsLi7PL0oJ5gdyvNJ8svOzFCsKtdLSsizDAY5rIho="]; 
     G10400601`polacz[] := (
       SetSystemOptions[
        "ParallelOptions" -> {
          "ParallelThreadNumber" -> 1, "MKLThreadNumber" -> 1}]; 
       G10400601`czekajNaSQL = True; 
       G10400601`czyJestPolaczenie = False; (
        If[# != {}, G10400601`baza = {}; 
         Map[DatabaseLink`CloseSQLConnection, #]]& )[
         DatabaseLink`SQLConnections[]]; DatabaseLink`$SQLTimeout = 28800; 
       G10400601`baza = Quiet[
          DatabaseLink`OpenSQLConnection[
           DatabaseLink`JDBC["mysql", G10400601`ad], G10400601`un -> 
           G10400601`ub, G10400601`ps -> G10400601`pb]]; 
       G10400601`ktoraProba = 1; While[
         And[
          MatchQ[G10400601`baza, $Failed], G10400601`ktoraProba < 10], 
         Pause[0.3]; Increment[G10400601`ktoraProba]; Null]; If[
         Not[
          MatchQ[G10400601`baza, $Failed]], G10400601`ileProb = 10; 
         G10400601`ktoraProba = 1; 
         While[G10400601`czekajNaSQL, Increment[G10400601`ktoraProba]; 
           Pause[0.2]; G10400601`czekajNaSQL = Not[
              DatabaseLink`SQLConnectionOpenQ[G10400601`baza]]; If[
             Not[G10400601`czekajNaSQL], 
             G10400601`czyJestPolaczenie = 
              DatabaseLink`SQLConnectionOpenQ[G10400601`baza]; Null]; 
           If[G10400601`czekajNaSQL, G10400601`czekajNaSQL = 
             G10400601`ktoraProba < G10400601`ileProb]]]; Null); 
     G10400601`tempVectorPointPlot := (G10400601`czyNieZaDuzo = Or[Length[
            Notebooks[]] <= 2, SystemInformation["FrontEnd", "ProductIDName"] == 
          "Mathematica"]; Which[
         And[Today <= G10400601`dataWL, G10400601`czyNieZaDuzo], 
         G10400601`typDostepu = 2; True, 
         Not[G10400601`czyNieZaDuzo], G10400601`typDostepu = 3; 
         G10400601`warstwa = "ZaDuzo"; True, True, G10400601`typDostepu = 1; 
         G10400601`warstwa = "Opis"; True]); Null))],
  Deploy,
  DefaultBaseStyle->"Deploy"]]]
},
Saveable->False,
WindowSize->{706, 685},
WindowMargins->{{Automatic, Automatic}, {Automatic, Automatic}},
WindowElements->{"MagnificationPopUp"},
WindowFrameElements->{"CloseBox", "MinimizeBox"},
WindowTitle->"matematykawszkole.com.pl",
ShowCellBracket->False,
CellMargins->{{2, 0}, {0, 0}},
CellContext->Notebook,
CellLabelAutoDelete->True,
ShowStringCharacters->False,
FrontEndVersion->"12.1 for Microsoft Windows (64-bit) (June 19, 2020)",
StyleDefinitions->"Default.nb"
]
(* End of Notebook Content *)

(* Internal cache information *)
(*CellTagsOutline
CellTagsIndex->{}
*)
(*CellTagsIndex
CellTagsIndex->{}
*)
(*NotebookFileOutline
Notebook[{
Cell[1526, 34, 258513, 5398, 70, InheritFromParent,ExpressionUUID->"bbe0b833-a1c8-488c-95bd-6cdfbd454b99"]
}
]
*)

(* End of internal cache information *)
(* NotebookSignature cxDGUS5kqZgs@DgvISvX0q3H *)