\begin{patch}{ugUserAnonDeclarePagePatch1}
\begin{paste}{ugUserAnonDeclarePageFull1}{ugUserAnonDeclarePageEmpty1}
\pastebutton{ugUserAnonDeclarePageFull1}{\hidepaste}
\tab{5}\spadcommand{(x: INT,y: INT): FRAC INT +-> (x + 2*y)/(y - 1)}
\indentrel{3}\begin{verbatim}
   (1)  theMap(*2;anonymousFunction;0;initial;internal)
        Type: ((Integer, Integer) -> Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty1}
\begin{paste}{ugUserAnonDeclarePageEmpty1}{ugUserAnonDeclarePagePatch1}
\pastebutton{ugUserAnonDeclarePageEmpty1}{\showpaste}
\tab{5}\spadcommand{(x: INT,y: INT): FRAC INT +-> (x + 2*y)/(y - 1)}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePagePatch2}
\begin{paste}{ugUserAnonDeclarePageFull2}{ugUserAnonDeclarePageEmpty2}
\pastebutton{ugUserAnonDeclarePageFull2}{\hidepaste}
\tab{5}\spadcommand{(x: INT,y: INT) +-> (x + 2*y)/(y - 1)}
\indentrel{3}\begin{verbatim}
   (2)  theMap(*2;anonymousFunction;1;initial;internal)
        Type: ((Integer, Integer) -> Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty2}
\begin{paste}{ugUserAnonDeclarePageEmpty2}{ugUserAnonDeclarePagePatch2}
\pastebutton{ugUserAnonDeclarePageEmpty2}{\showpaste}
\tab{5}\spadcommand{(x: INT,y: INT) +-> (x + 2*y)/(y - 1)}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePagePatch3}
\begin{paste}{ugUserAnonDeclarePageFull3}{ugUserAnonDeclarePageEmpty3}
\pastebutton{ugUserAnonDeclarePageFull3}{\hidepaste}
\tab{5}\spadcommand{h(x: INT,y: INT): FRAC INT == (x + 2*y)/(y - 1)}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty3}
\begin{paste}{ugUserAnonDeclarePageEmpty3}{ugUserAnonDeclarePagePatch3}
\pastebutton{ugUserAnonDeclarePageEmpty3}{\showpaste}
\tab{5}\spadcommand{h(x: INT,y: INT): FRAC INT == (x + 2*y)/(y - 1)}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePagePatch4}
\begin{paste}{ugUserAnonDeclarePageFull4}{ugUserAnonDeclarePageEmpty4}
\pastebutton{ugUserAnonDeclarePageFull4}{\hidepaste}
\tab{5}\spadcommand{h == (x: INT,y: INT): FRAC INT +-> (x + 2*y)/(y - 1)}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty4}
\begin{paste}{ugUserAnonDeclarePageEmpty4}{ugUserAnonDeclarePagePatch4}
\pastebutton{ugUserAnonDeclarePageEmpty4}{\showpaste}
\tab{5}\spadcommand{h == (x: INT,y: INT): FRAC INT +-> (x + 2*y)/(y - 1)}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePagePatch5}
\begin{paste}{ugUserAnonDeclarePageFull5}{ugUserAnonDeclarePageEmpty5}
\pastebutton{ugUserAnonDeclarePageFull5}{\hidepaste}
\tab{5}\spadcommand{addx x == ((y: Integer): Integer +-> x + y)\bound{addx }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty5}
\begin{paste}{ugUserAnonDeclarePageEmpty5}{ugUserAnonDeclarePagePatch5}
\pastebutton{ugUserAnonDeclarePageEmpty5}{\showpaste}
\tab{5}\spadcommand{addx x == ((y: Integer): Integer +-> x + y)\bound{addx }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePagePatch6}
\begin{paste}{ugUserAnonDeclarePageFull6}{ugUserAnonDeclarePageEmpty6}
\pastebutton{ugUserAnonDeclarePageFull6}{\hidepaste}
\tab{5}\spadcommand{g := addx 10\free{addx }\bound{g }}
\indentrel{3}\begin{verbatim}
   (6)
   theMap
     #<FUNCTION (LAMBDA (#:G4 |envArg|) :IN |*1;addx;1;in
     itial|) {53926D6B}>
  ,
      1
                             Type: (Integer -> Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty6}
\begin{paste}{ugUserAnonDeclarePageEmpty6}{ugUserAnonDeclarePagePatch6}
\pastebutton{ugUserAnonDeclarePageEmpty6}{\showpaste}
\tab{5}\spadcommand{g := addx 10\free{addx }\bound{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePagePatch7}
\begin{paste}{ugUserAnonDeclarePageFull7}{ugUserAnonDeclarePageEmpty7}
\pastebutton{ugUserAnonDeclarePageFull7}{\hidepaste}
\tab{5}\spadcommand{g 3\free{g }}
\indentrel{3}\begin{verbatim}
   (7)  13
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty7}
\begin{paste}{ugUserAnonDeclarePageEmpty7}{ugUserAnonDeclarePagePatch7}
\pastebutton{ugUserAnonDeclarePageEmpty7}{\showpaste}
\tab{5}\spadcommand{g 3\free{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePagePatch8}
\begin{paste}{ugUserAnonDeclarePageFull8}{ugUserAnonDeclarePageEmpty8}
\pastebutton{ugUserAnonDeclarePageFull8}{\hidepaste}
\tab{5}\spadcommand{g(-4)\free{g }}
\indentrel{3}\begin{verbatim}
   (8)  6
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonDeclarePageEmpty8}
\begin{paste}{ugUserAnonDeclarePageEmpty8}{ugUserAnonDeclarePagePatch8}
\pastebutton{ugUserAnonDeclarePageEmpty8}{\showpaste}
\tab{5}\spadcommand{g(-4)\free{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch1}
\begin{paste}{ugUserPiecePickingPageFull1}{ugUserPiecePickingPageEmpty1}
\pastebutton{ugUserPiecePickingPageFull1}{\hidepaste}
\tab{5}\spadcommand{eleven(n | n < 1) == n + 11\bound{ff0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty1}
\begin{paste}{ugUserPiecePickingPageEmpty1}{ugUserPiecePickingPagePatch1}
\pastebutton{ugUserPiecePickingPageEmpty1}{\showpaste}
\tab{5}\spadcommand{eleven(n | n < 1) == n + 11\bound{ff0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch2}
\begin{paste}{ugUserPiecePickingPageFull2}{ugUserPiecePickingPageEmpty2}
\pastebutton{ugUserPiecePickingPageFull2}{\hidepaste}
\tab{5}\spadcommand{eleven(m) == eleven(eleven(m - 12))\bound{ff1 }\free{ff0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty2}
\begin{paste}{ugUserPiecePickingPageEmpty2}{ugUserPiecePickingPagePatch2}
\pastebutton{ugUserPiecePickingPageEmpty2}{\showpaste}
\tab{5}\spadcommand{eleven(m) == eleven(eleven(m - 12))\bound{ff1 }\free{ff0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch3}
\begin{paste}{ugUserPiecePickingPageFull3}{ugUserPiecePickingPageEmpty3}
\pastebutton{ugUserPiecePickingPageFull3}{\hidepaste}
\tab{5}\spadcommand{minusEleven(n) ==
  n >= 0 => n - 11
  minusEleven (5 + minusEleven(n + 7))
\bound{rf1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty3}
\begin{paste}{ugUserPiecePickingPageEmpty3}{ugUserPiecePickingPagePatch3}
\pastebutton{ugUserPiecePickingPageEmpty3}{\showpaste}
\tab{5}\spadcommand{minusEleven(n) ==
  n >= 0 => n - 11
  minusEleven (5 + minusEleven(n + 7))
\bound{rf1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch4}
\begin{paste}{ugUserPiecePickingPageFull4}{ugUserPiecePickingPageEmpty4}
\pastebutton{ugUserPiecePickingPageFull4}{\hidepaste}
\tab{5}\spadcommand{s(0) == 1\bound{rf2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty4}
\begin{paste}{ugUserPiecePickingPageEmpty4}{ugUserPiecePickingPagePatch4}
\pastebutton{ugUserPiecePickingPageEmpty4}{\showpaste}
\tab{5}\spadcommand{s(0) == 1\bound{rf2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch5}
\begin{paste}{ugUserPiecePickingPageFull5}{ugUserPiecePickingPageEmpty5}
\pastebutton{ugUserPiecePickingPageFull5}{\hidepaste}
\tab{5}\spadcommand{s(n) == (eleven(n) + minusEleven(n))/n\bound{rf3 }\free{rf2 rf1 ff1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty5}
\begin{paste}{ugUserPiecePickingPageEmpty5}{ugUserPiecePickingPagePatch5}
\pastebutton{ugUserPiecePickingPageEmpty5}{\showpaste}
\tab{5}\spadcommand{s(n) == (eleven(n) + minusEleven(n))/n\bound{rf3 }\free{rf2 rf1 ff1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch6}
\begin{paste}{ugUserPiecePickingPageFull6}{ugUserPiecePickingPageEmpty6}
\pastebutton{ugUserPiecePickingPageFull6}{\hidepaste}
\tab{5}\spadcommand{[s(n) for n in 0..]\free{rf3 }}
\indentrel{3}\begin{verbatim}
   (6)  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...]
                        Type: Stream(Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty6}
\begin{paste}{ugUserPiecePickingPageEmpty6}{ugUserPiecePickingPagePatch6}
\pastebutton{ugUserPiecePickingPageEmpty6}{\showpaste}
\tab{5}\spadcommand{[s(n) for n in 0..]\free{rf3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch7}
\begin{paste}{ugUserPiecePickingPageFull7}{ugUserPiecePickingPageEmpty7}
\pastebutton{ugUserPiecePickingPageFull7}{\hidepaste}
\tab{5}\spadcommand{t(1) == s(0)\bound{t1 }\free{rf4 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty7}
\begin{paste}{ugUserPiecePickingPageEmpty7}{ugUserPiecePickingPagePatch7}
\pastebutton{ugUserPiecePickingPageEmpty7}{\showpaste}
\tab{5}\spadcommand{t(1) == s(0)\bound{t1 }\free{rf4 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch8}
\begin{paste}{ugUserPiecePickingPageFull8}{ugUserPiecePickingPageEmpty8}
\pastebutton{ugUserPiecePickingPageFull8}{\hidepaste}
\tab{5}\spadcommand{t(n | even?(n)) == s(n quo 2)\free{t1 }\bound{t2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty8}
\begin{paste}{ugUserPiecePickingPageEmpty8}{ugUserPiecePickingPagePatch8}
\pastebutton{ugUserPiecePickingPageEmpty8}{\showpaste}
\tab{5}\spadcommand{t(n | even?(n)) == s(n quo 2)\free{t1 }\bound{t2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch9}
\begin{paste}{ugUserPiecePickingPageFull9}{ugUserPiecePickingPageEmpty9}
\pastebutton{ugUserPiecePickingPageFull9}{\hidepaste}
\tab{5}\spadcommand{t(p) == s(- p quo 2)\free{t2 }\bound{t3 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty9}
\begin{paste}{ugUserPiecePickingPageEmpty9}{ugUserPiecePickingPagePatch9}
\pastebutton{ugUserPiecePickingPageEmpty9}{\showpaste}
\tab{5}\spadcommand{t(p) == s(- p quo 2)\free{t2 }\bound{t3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch10}
\begin{paste}{ugUserPiecePickingPageFull10}{ugUserPiecePickingPageEmpty10}
\pastebutton{ugUserPiecePickingPageFull10}{\hidepaste}
\tab{5}\spadcommand{)display value t\free{t2 }}
\indentrel{3}\begin{verbatim}
   CONCAT
      Definition:
  ,
      t1 == s(0)
      t(p | even?(p)) == s(p quo 2)
      t(p) == s(- p quo 2)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty10}
\begin{paste}{ugUserPiecePickingPageEmpty10}{ugUserPiecePickingPagePatch10}
\pastebutton{ugUserPiecePickingPageEmpty10}{\showpaste}
\tab{5}\spadcommand{)display value t\free{t2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch11}
\begin{paste}{ugUserPiecePickingPageFull11}{ugUserPiecePickingPageEmpty11}
\pastebutton{ugUserPiecePickingPageFull11}{\hidepaste}
\tab{5}\spadcommand{[t(i) for i in 1..]\free{t3 }\bound{t4 }}
\indentrel{3}\begin{verbatim}
   (10)  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...]
                        Type: Stream(Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty11}
\begin{paste}{ugUserPiecePickingPageEmpty11}{ugUserPiecePickingPagePatch11}
\pastebutton{ugUserPiecePickingPageEmpty11}{\showpaste}
\tab{5}\spadcommand{[t(i) for i in 1..]\free{t3 }\bound{t4 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPagePatch12}
\begin{paste}{ugUserPiecePickingPageFull12}{ugUserPiecePickingPageEmpty12}
\pastebutton{ugUserPiecePickingPageFull12}{\hidepaste}
\tab{5}\spadcommand{t(100)\free{t4 }}
\indentrel{3}\begin{verbatim}
   (11)  1
                                Type: Fraction(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePickingPageEmpty12}
\begin{paste}{ugUserPiecePickingPageEmpty12}{ugUserPiecePickingPagePatch12}
\pastebutton{ugUserPiecePickingPageEmpty12}{\showpaste}
\tab{5}\spadcommand{t(100)\free{t4 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch1}
\begin{paste}{ugUserPalPageFull1}{ugUserPalPageEmpty1}
\pastebutton{ugUserPalPageFull1}{\hidepaste}
\tab{5}\spadcommand{pal? s == palAux?(s,1,\#s)\bound{pal }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty1}
\begin{paste}{ugUserPalPageEmpty1}{ugUserPalPagePatch1}
\pastebutton{ugUserPalPageEmpty1}{\showpaste}
\tab{5}\spadcommand{pal? s == palAux?(s,1,\#s)\bound{pal }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch2}
\begin{paste}{ugUserPalPageFull2}{ugUserPalPageEmpty2}
\pastebutton{ugUserPalPageFull2}{\hidepaste}
\tab{5}\spadcommand{palAux?(s,i,j) ==
  j > i =>
    (s.i = s.j) and palAux?(s,i+1,j-1)
  true
\bound{palAux }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty2}
\begin{paste}{ugUserPalPageEmpty2}{ugUserPalPagePatch2}
\pastebutton{ugUserPalPageEmpty2}{\showpaste}
\tab{5}\spadcommand{palAux?(s,i,j) ==
  j > i =>
    (s.i = s.j) and palAux?(s,i+1,j-1)
  true
\bound{palAux }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch3}
\begin{paste}{ugUserPalPageFull3}{ugUserPalPageEmpty3}
\pastebutton{ugUserPalPageFull3}{\hidepaste}
\tab{5}\spadcommand{pal? "Oxford"\free{pal palAux }}
\indentrel{3}\begin{verbatim}
   (3)  false
                                          Type: Boolean
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty3}
\begin{paste}{ugUserPalPageEmpty3}{ugUserPalPagePatch3}
\pastebutton{ugUserPalPageEmpty3}{\showpaste}
\tab{5}\spadcommand{pal? "Oxford"\free{pal palAux }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch4}
\begin{paste}{ugUserPalPageFull4}{ugUserPalPageEmpty4}
\pastebutton{ugUserPalPageFull4}{\hidepaste}
\tab{5}\spadcommand{pal? [4,a,x-1,0,x-1,a,4]\free{pal palAux }}
\indentrel{3}\begin{verbatim}
   (4)  true
                                          Type: Boolean
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty4}
\begin{paste}{ugUserPalPageEmpty4}{ugUserPalPagePatch4}
\pastebutton{ugUserPalPageEmpty4}{\showpaste}
\tab{5}\spadcommand{pal? [4,a,x-1,0,x-1,a,4]\free{pal palAux }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch5}
\begin{paste}{ugUserPalPageFull5}{ugUserPalPageEmpty5}
\pastebutton{ugUserPalPageFull5}{\hidepaste}
\tab{5}\spadcommand{pal? [1,6,15,20,15,6,1]\free{pal palAux }}
\indentrel{3}\begin{verbatim}
   (5)  true
                                          Type: Boolean
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty5}
\begin{paste}{ugUserPalPageEmpty5}{ugUserPalPagePatch5}
\pastebutton{ugUserPalPageEmpty5}{\showpaste}
\tab{5}\spadcommand{pal? [1,6,15,20,15,6,1]\free{pal palAux }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch6}
\begin{paste}{ugUserPalPageFull6}{ugUserPalPageEmpty6}
\pastebutton{ugUserPalPageFull6}{\hidepaste}
\tab{5}\spadcommand{pal?(1441::String)\free{pal palAux }}
\indentrel{3}\begin{verbatim}
   (6)  true
                                          Type: Boolean
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty6}
\begin{paste}{ugUserPalPageEmpty6}{ugUserPalPagePatch6}
\pastebutton{ugUserPalPageEmpty6}{\showpaste}
\tab{5}\spadcommand{pal?(1441::String)\free{pal palAux }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch7}
\begin{paste}{ugUserPalPageFull7}{ugUserPalPageEmpty7}
\pastebutton{ugUserPalPageFull7}{\hidepaste}
\tab{5}\spadcommand{ones := [reduce(+,[10^j for j in 0..i]) for i in 1..]\free{pal palAux }\bound{pal5 }}
\indentrel{3}\begin{verbatim}
   (7)
   [11, 111, 1111, 11111, 111111, 1111111, 11111111,
    111111111, 1111111111, 11111111111, ...]
                          Type: Stream(PositiveInteger)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty7}
\begin{paste}{ugUserPalPageEmpty7}{ugUserPalPagePatch7}
\pastebutton{ugUserPalPageEmpty7}{\showpaste}
\tab{5}\spadcommand{ones := [reduce(+,[10^j for j in 0..i]) for i in 1..]\free{pal palAux }\bound{pal5 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch8}
\begin{paste}{ugUserPalPageFull8}{ugUserPalPageEmpty8}
\pastebutton{ugUserPalPageFull8}{\hidepaste}
\tab{5}\spadcommand{squares := [x^2 for x in ones]\free{pal5 }\bound{pal6 }}
\indentrel{3}\begin{verbatim}
   (8)
   [121, 12321, 1234321, 123454321, 12345654321,
    1234567654321, 123456787654321, 12345678987654321,
    1234567900987654321, 123456790120987654321, ...]
                          Type: Stream(PositiveInteger)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty8}
\begin{paste}{ugUserPalPageEmpty8}{ugUserPalPagePatch8}
\pastebutton{ugUserPalPageEmpty8}{\showpaste}
\tab{5}\spadcommand{squares := [x^2 for x in ones]\free{pal5 }\bound{pal6 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPalPagePatch9}
\begin{paste}{ugUserPalPageFull9}{ugUserPalPageEmpty9}
\pastebutton{ugUserPalPageFull9}{\hidepaste}
\tab{5}\spadcommand{[pal?(x::String) for x in squares]\free{pal6 }}
\indentrel{3}\begin{verbatim}
   (9)
   [true, true, true, true, true, true, true, true,
    false, false, ...]
                                  Type: Stream(Boolean)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPalPageEmpty9}
\begin{paste}{ugUserPalPageEmpty9}{ugUserPalPagePatch9}
\pastebutton{ugUserPalPageEmpty9}{\showpaste}
\tab{5}\spadcommand{[pal?(x::String) for x in squares]\free{pal6 }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch1}
\begin{paste}{ugUserOnePageFull1}{ugUserOnePageEmpty1}
\pastebutton{ugUserOnePageFull1}{\hidepaste}
\tab{5}\spadcommand{fac n == if n < 3 then n else n * fac(n-1)\bound{fac }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty1}
\begin{paste}{ugUserOnePageEmpty1}{ugUserOnePagePatch1}
\pastebutton{ugUserOnePageEmpty1}{\showpaste}
\tab{5}\spadcommand{fac n == if n < 3 then n else n * fac(n-1)\bound{fac }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch2}
\begin{paste}{ugUserOnePageFull2}{ugUserOnePageEmpty2}
\pastebutton{ugUserOnePageFull2}{\hidepaste}
\tab{5}\spadcommand{fac 10\free{fac }}
\indentrel{3}\begin{verbatim}
   (2)  3628800
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty2}
\begin{paste}{ugUserOnePageEmpty2}{ugUserOnePagePatch2}
\pastebutton{ugUserOnePageEmpty2}{\showpaste}
\tab{5}\spadcommand{fac 10\free{fac }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch3}
\begin{paste}{ugUserOnePageFull3}{ugUserOnePageEmpty3}
\pastebutton{ugUserOnePageFull3}{\hidepaste}
\tab{5}\spadcommand{s n == reduce(+,[1/i for i in 1..n])\bound{s }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty3}
\begin{paste}{ugUserOnePageEmpty3}{ugUserOnePagePatch3}
\pastebutton{ugUserOnePageEmpty3}{\showpaste}
\tab{5}\spadcommand{s n == reduce(+,[1/i for i in 1..n])\bound{s }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch4}
\begin{paste}{ugUserOnePageFull4}{ugUserOnePageEmpty4}
\pastebutton{ugUserOnePageFull4}{\hidepaste}
\tab{5}\spadcommand{s 50\free{s }}
\indentrel{3}\begin{verbatim}
        13943237577224054960759
   (4)  -----------------------
         3099044504245996706400
                                Type: Fraction(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty4}
\begin{paste}{ugUserOnePageEmpty4}{ugUserOnePagePatch4}
\pastebutton{ugUserOnePageEmpty4}{\showpaste}
\tab{5}\spadcommand{s 50\free{s }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch5}
\begin{paste}{ugUserOnePageFull5}{ugUserOnePageEmpty5}
\pastebutton{ugUserOnePageFull5}{\hidepaste}
\tab{5}\spadcommand{mersenne i == 2^i - 1\bound{mersenne }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty5}
\begin{paste}{ugUserOnePageEmpty5}{ugUserOnePagePatch5}
\pastebutton{ugUserOnePageEmpty5}{\showpaste}
\tab{5}\spadcommand{mersenne i == 2^i - 1\bound{mersenne }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch6}
\begin{paste}{ugUserOnePageFull6}{ugUserOnePageEmpty6}
\pastebutton{ugUserOnePageFull6}{\hidepaste}
\tab{5}\spadcommand{mersenne\free{mersenne }}
\indentrel{3}\begin{verbatim}
                        i
   (6)  mersenne(i) == 2  - 1
                         Type: FunctionCalled(mersenne)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty6}
\begin{paste}{ugUserOnePageEmpty6}{ugUserOnePagePatch6}
\pastebutton{ugUserOnePageEmpty6}{\showpaste}
\tab{5}\spadcommand{mersenne\free{mersenne }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch7}
\begin{paste}{ugUserOnePageFull7}{ugUserOnePageEmpty7}
\pastebutton{ugUserOnePageFull7}{\hidepaste}
\tab{5}\spadcommand{[mersenne i for i in 1..]\free{mersenne }}
\indentrel{3}\begin{verbatim}
   (7)  [1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, ...]
                                  Type: Stream(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty7}
\begin{paste}{ugUserOnePageEmpty7}{ugUserOnePagePatch7}
\pastebutton{ugUserOnePageEmpty7}{\showpaste}
\tab{5}\spadcommand{[mersenne i for i in 1..]\free{mersenne }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch8}
\begin{paste}{ugUserOnePageFull8}{ugUserOnePageEmpty8}
\pastebutton{ugUserOnePageFull8}{\hidepaste}
\tab{5}\spadcommand{mersenneIndex := [n for n in 1.. | prime?(mersenne(n))]\bound{mersenneIndex }\free{mersenne }}
\indentrel{3}\begin{verbatim}
   (8)  [2, 3, 5, 7, 13, 17, 19, 31, 61, 89, ...]
                          Type: Stream(PositiveInteger)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty8}
\begin{paste}{ugUserOnePageEmpty8}{ugUserOnePagePatch8}
\pastebutton{ugUserOnePageEmpty8}{\showpaste}
\tab{5}\spadcommand{mersenneIndex := [n for n in 1.. | prime?(mersenne(n))]\bound{mersenneIndex }\free{mersenne }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch9}
\begin{paste}{ugUserOnePageFull9}{ugUserOnePageEmpty9}
\pastebutton{ugUserOnePageFull9}{\hidepaste}
\tab{5}\spadcommand{mersennePrime n == mersenne mersenneIndex(n)\free{mersenne mersenneIndex }\bound{mersennePrime }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty9}
\begin{paste}{ugUserOnePageEmpty9}{ugUserOnePagePatch9}
\pastebutton{ugUserOnePageEmpty9}{\showpaste}
\tab{5}\spadcommand{mersennePrime n == mersenne mersenneIndex(n)\free{mersenne mersenneIndex }\bound{mersennePrime }}
\end{paste}\end{patch}

\begin{patch}{ugUserOnePagePatch10}
\begin{paste}{ugUserOnePageFull10}{ugUserOnePageEmpty10}
\pastebutton{ugUserOnePageFull10}{\hidepaste}
\tab{5}\spadcommand{mersennePrime 5\free{mersennePrime }}
\indentrel{3}\begin{verbatim}
   (10)  8191
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserOnePageEmpty10}
\begin{paste}{ugUserOnePageEmpty10}{ugUserOnePagePatch10}
\pastebutton{ugUserOnePageEmpty10}{\showpaste}
\tab{5}\spadcommand{mersennePrime 5\free{mersennePrime }}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch1}
\begin{paste}{ugUserUsePageFull1}{ugUserUsePageEmpty1}
\pastebutton{ugUserUsePageFull1}{\hidepaste}
\tab{5}\spadcommand{sin x == 1.0\bound{sin }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty1}
\begin{paste}{ugUserUsePageEmpty1}{ugUserUsePagePatch1}
\pastebutton{ugUserUsePageEmpty1}{\showpaste}
\tab{5}\spadcommand{sin x == 1.0\bound{sin }}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch2}
\begin{paste}{ugUserUsePageFull2}{ugUserUsePageEmpty2}
\pastebutton{ugUserUsePageFull2}{\hidepaste}
\tab{5}\spadcommand{sin 4.3\free{sin }}
\indentrel{3}\begin{verbatim}
   (2)  1.0
                                            Type: Float
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty2}
\begin{paste}{ugUserUsePageEmpty2}{ugUserUsePagePatch2}
\pastebutton{ugUserUsePageEmpty2}{\showpaste}
\tab{5}\spadcommand{sin 4.3\free{sin }}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch3}
\begin{paste}{ugUserUsePageFull3}{ugUserUsePageEmpty3}
\pastebutton{ugUserUsePageFull3}{\hidepaste}
\tab{5}\spadcommand{sin(4.3)$Float}
\indentrel{3}\begin{verbatim}
   (3)  - 0.9161659367_4945498404
                                            Type: Float
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty3}
\begin{paste}{ugUserUsePageEmpty3}{ugUserUsePagePatch3}
\pastebutton{ugUserUsePageEmpty3}{\showpaste}
\tab{5}\spadcommand{sin(4.3)$Float}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch4}
\begin{paste}{ugUserUsePageFull4}{ugUserUsePageEmpty4}
\pastebutton{ugUserUsePageFull4}{\hidepaste}
\tab{5}\spadcommand{sin(34.6)$Float}
\indentrel{3}\begin{verbatim}
   (4)  - 0.0424680347_1695010154_3
                                            Type: Float
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty4}
\begin{paste}{ugUserUsePageEmpty4}{ugUserUsePagePatch4}
\pastebutton{ugUserUsePageEmpty4}{\showpaste}
\tab{5}\spadcommand{sin(34.6)$Float}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch5}
\begin{paste}{ugUserUsePageFull5}{ugUserUsePageEmpty5}
\pastebutton{ugUserUsePageFull5}{\hidepaste}
\tab{5}\spadcommand{sin x == sin x\bound{sin1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty5}
\begin{paste}{ugUserUsePageEmpty5}{ugUserUsePagePatch5}
\pastebutton{ugUserUsePageEmpty5}{\showpaste}
\tab{5}\spadcommand{sin x == sin x\bound{sin1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch6}
\begin{paste}{ugUserUsePageFull6}{ugUserUsePageEmpty6}
\pastebutton{ugUserUsePageFull6}{\hidepaste}
\tab{5}\spadcommand{sin 4.3\free{sin1 }}
\indentrel{3}\begin{verbatim}
error
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty6}
\begin{paste}{ugUserUsePageEmpty6}{ugUserUsePagePatch6}
\pastebutton{ugUserUsePageEmpty6}{\showpaste}
\tab{5}\spadcommand{sin 4.3\free{sin1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch7}
\begin{paste}{ugUserUsePageFull7}{ugUserUsePageEmpty7}
\pastebutton{ugUserUsePageFull7}{\hidepaste}
\tab{5}\spadcommand{sin x == sin(x)$Float\bound{sin2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty7}
\begin{paste}{ugUserUsePageEmpty7}{ugUserUsePagePatch7}
\pastebutton{ugUserUsePageEmpty7}{\showpaste}
\tab{5}\spadcommand{sin x == sin(x)$Float\bound{sin2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserUsePagePatch8}
\begin{paste}{ugUserUsePageFull8}{ugUserUsePageEmpty8}
\pastebutton{ugUserUsePageFull8}{\hidepaste}
\tab{5}\spadcommand{sin 4.3\free{sin2 }}
\indentrel{3}\begin{verbatim}
   (7)  - 0.9161659367_4945498404
                                            Type: Float
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserUsePageEmpty8}
\begin{paste}{ugUserUsePageEmpty8}{ugUserUsePagePatch8}
\pastebutton{ugUserUsePageEmpty8}{\showpaste}
\tab{5}\spadcommand{sin 4.3\free{sin2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch1}
\begin{paste}{ugUserMakePageFull1}{ugUserMakePageEmpty1}
\pastebutton{ugUserMakePageFull1}{\hidepaste}
\tab{5}\spadcommand{p := -x + y^2 - z^3\bound{p }}
\indentrel{3}\begin{verbatim}
           3    2
   (1)  - z  + y  - x
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty1}
\begin{paste}{ugUserMakePageEmpty1}{ugUserMakePagePatch1}
\pastebutton{ugUserMakePageEmpty1}{\showpaste}
\tab{5}\spadcommand{p := -x + y^2 - z^3\bound{p }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch2}
\begin{paste}{ugUserMakePageFull2}{ugUserMakePageEmpty2}
\pastebutton{ugUserMakePageFull2}{\hidepaste}
\tab{5}\spadcommand{function(p,'f0)\free{p }\bound{f0 }}
\indentrel{3}\begin{verbatim}
   (2)  f0
                                           Type: Symbol
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty2}
\begin{paste}{ugUserMakePageEmpty2}{ugUserMakePagePatch2}
\pastebutton{ugUserMakePageEmpty2}{\showpaste}
\tab{5}\spadcommand{function(p,'f0)\free{p }\bound{f0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch3}
\begin{paste}{ugUserMakePageFull3}{ugUserMakePageEmpty3}
\pastebutton{ugUserMakePageFull3}{\hidepaste}
\tab{5}\spadcommand{f0\free{f0 }}
\indentrel{3}\begin{verbatim}
                   3    2
   (3)  f0() == - z  + y  - x
                               Type: FunctionCalled(f0)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty3}
\begin{paste}{ugUserMakePageEmpty3}{ugUserMakePagePatch3}
\pastebutton{ugUserMakePageEmpty3}{\showpaste}
\tab{5}\spadcommand{f0\free{f0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch4}
\begin{paste}{ugUserMakePageFull4}{ugUserMakePageEmpty4}
\pastebutton{ugUserMakePageFull4}{\hidepaste}
\tab{5}\spadcommand{f0()\free{f0 }}
\indentrel{3}\begin{verbatim}
           3    2
   (4)  - z  + y  - x
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty4}
\begin{paste}{ugUserMakePageEmpty4}{ugUserMakePagePatch4}
\pastebutton{ugUserMakePageEmpty4}{\showpaste}
\tab{5}\spadcommand{f0()\free{f0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch5}
\begin{paste}{ugUserMakePageFull5}{ugUserMakePageEmpty5}
\pastebutton{ugUserMakePageFull5}{\hidepaste}
\tab{5}\spadcommand{function(p,'f1,'x)\free{p }\bound{f1 }}
\indentrel{3}\begin{verbatim}
   (5)  f1
                                           Type: Symbol
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty5}
\begin{paste}{ugUserMakePageEmpty5}{ugUserMakePagePatch5}
\pastebutton{ugUserMakePageEmpty5}{\showpaste}
\tab{5}\spadcommand{function(p,'f1,'x)\free{p }\bound{f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch6}
\begin{paste}{ugUserMakePageFull6}{ugUserMakePageEmpty6}
\pastebutton{ugUserMakePageFull6}{\hidepaste}
\tab{5}\spadcommand{f1\free{f1 }}
\indentrel{3}\begin{verbatim}
                    3    2
   (6)  f1(x) == - z  + y  - x
                               Type: FunctionCalled(f1)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty6}
\begin{paste}{ugUserMakePageEmpty6}{ugUserMakePagePatch6}
\pastebutton{ugUserMakePageEmpty6}{\showpaste}
\tab{5}\spadcommand{f1\free{f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch7}
\begin{paste}{ugUserMakePageFull7}{ugUserMakePageEmpty7}
\pastebutton{ugUserMakePageFull7}{\hidepaste}
\tab{5}\spadcommand{f1(3)\free{f1 }}
\indentrel{3}\begin{verbatim}
           3    2
   (7)  - z  + y  - 3
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty7}
\begin{paste}{ugUserMakePageEmpty7}{ugUserMakePagePatch7}
\pastebutton{ugUserMakePageEmpty7}{\showpaste}
\tab{5}\spadcommand{f1(3)\free{f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch8}
\begin{paste}{ugUserMakePageFull8}{ugUserMakePageEmpty8}
\pastebutton{ugUserMakePageFull8}{\hidepaste}
\tab{5}\spadcommand{function(p,'f2,'x,'y)\free{p }\bound{f2 }}
\indentrel{3}\begin{verbatim}
   (8)  f2
                                           Type: Symbol
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty8}
\begin{paste}{ugUserMakePageEmpty8}{ugUserMakePagePatch8}
\pastebutton{ugUserMakePageEmpty8}{\showpaste}
\tab{5}\spadcommand{function(p,'f2,'x,'y)\free{p }\bound{f2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch9}
\begin{paste}{ugUserMakePageFull9}{ugUserMakePageEmpty9}
\pastebutton{ugUserMakePageFull9}{\hidepaste}
\tab{5}\spadcommand{f2\free{f2 }}
\indentrel{3}\begin{verbatim}
                       3    2
   (9)  f2(x, y) == - z  + y  - x
                               Type: FunctionCalled(f2)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty9}
\begin{paste}{ugUserMakePageEmpty9}{ugUserMakePagePatch9}
\pastebutton{ugUserMakePageEmpty9}{\showpaste}
\tab{5}\spadcommand{f2\free{f2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch10}
\begin{paste}{ugUserMakePageFull10}{ugUserMakePageEmpty10}
\pastebutton{ugUserMakePageFull10}{\hidepaste}
\tab{5}\spadcommand{f2(3,0)\free{f2 }}
\indentrel{3}\begin{verbatim}
            3
   (10)  - z  - 3
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty10}
\begin{paste}{ugUserMakePageEmpty10}{ugUserMakePagePatch10}
\pastebutton{ugUserMakePageEmpty10}{\showpaste}
\tab{5}\spadcommand{f2(3,0)\free{f2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch11}
\begin{paste}{ugUserMakePageFull11}{ugUserMakePageEmpty11}
\pastebutton{ugUserMakePageFull11}{\hidepaste}
\tab{5}\spadcommand{function(p,'f3,['x,'y,'z])\free{p }\bound{f3 }}
\indentrel{3}\begin{verbatim}
   (11)  f3
                                           Type: Symbol
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty11}
\begin{paste}{ugUserMakePageEmpty11}{ugUserMakePagePatch11}
\pastebutton{ugUserMakePageEmpty11}{\showpaste}
\tab{5}\spadcommand{function(p,'f3,['x,'y,'z])\free{p }\bound{f3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch12}
\begin{paste}{ugUserMakePageFull12}{ugUserMakePageEmpty12}
\pastebutton{ugUserMakePageFull12}{\hidepaste}
\tab{5}\spadcommand{f3\free{f3 }}
\indentrel{3}\begin{verbatim}
                           3    2
   (12)  f3(x, y, z) == - z  + y  - x
                               Type: FunctionCalled(f3)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty12}
\begin{paste}{ugUserMakePageEmpty12}{ugUserMakePagePatch12}
\pastebutton{ugUserMakePageEmpty12}{\showpaste}
\tab{5}\spadcommand{f3\free{f3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch13}
\begin{paste}{ugUserMakePageFull13}{ugUserMakePageEmpty13}
\pastebutton{ugUserMakePageFull13}{\hidepaste}
\tab{5}\spadcommand{f3(3,0,-6)\free{f3 }}
\indentrel{3}\begin{verbatim}
   (13)  213
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty13}
\begin{paste}{ugUserMakePageEmpty13}{ugUserMakePagePatch13}
\pastebutton{ugUserMakePageEmpty13}{\showpaste}
\tab{5}\spadcommand{f3(3,0,-6)\free{f3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch14}
\begin{paste}{ugUserMakePageFull14}{ugUserMakePageEmpty14}
\pastebutton{ugUserMakePageFull14}{\hidepaste}
\tab{5}\spadcommand{g: (Integer, Integer) -> Float\bound{g }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty14}
\begin{paste}{ugUserMakePageEmpty14}{ugUserMakePagePatch14}
\pastebutton{ugUserMakePageEmpty14}{\showpaste}
\tab{5}\spadcommand{g: (Integer, Integer) -> Float\bound{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch15}
\begin{paste}{ugUserMakePageFull15}{ugUserMakePageEmpty15}
\pastebutton{ugUserMakePageFull15}{\hidepaste}
\tab{5}\spadcommand{D(sin(x-y)/cos(x+y),x)\bound{prev }}
\indentrel{3}\begin{verbatim}
         - sin(y - x)sin(y + x) + cos(y - x)cos(y + x)
   (15)  ---------------------------------------------
                                    2
                          cos(y + x)
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty15}
\begin{paste}{ugUserMakePageEmpty15}{ugUserMakePagePatch15}
\pastebutton{ugUserMakePageEmpty15}{\showpaste}
\tab{5}\spadcommand{D(sin(x-y)/cos(x+y),x)\bound{prev }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch16}
\begin{paste}{ugUserMakePageFull16}{ugUserMakePageEmpty16}
\pastebutton{ugUserMakePageFull16}{\hidepaste}
\tab{5}\spadcommand{function(\%,'g,'x,'y)\free{g }\free{prev }}
\indentrel{3}\begin{verbatim}
   (16)  g
                                           Type: Symbol
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty16}
\begin{paste}{ugUserMakePageEmpty16}{ugUserMakePagePatch16}
\pastebutton{ugUserMakePageEmpty16}{\showpaste}
\tab{5}\spadcommand{function(\%,'g,'x,'y)\free{g }\free{prev }}
\end{paste}\end{patch}

\begin{patch}{ugUserMakePagePatch17}
\begin{paste}{ugUserMakePageFull17}{ugUserMakePageEmpty17}
\pastebutton{ugUserMakePageFull17}{\hidepaste}
\tab{5}\spadcommand{g\free{g }}
\indentrel{3}\begin{verbatim}
   (17)
   g(x, y) ==
     - sin(y - x)sin(y + x) + cos(y - x)cos(y + x)
     ---------------------------------------------
                                2
                      cos(y + x)
                                Type: FunctionCalled(g)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMakePageEmpty17}
\begin{paste}{ugUserMakePageEmpty17}{ugUserMakePagePatch17}
\pastebutton{ugUserMakePageEmpty17}{\showpaste}
\tab{5}\spadcommand{g\free{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserCachePagePatch1}
\begin{paste}{ugUserCachePageFull1}{ugUserCachePageEmpty1}
\pastebutton{ugUserCachePageFull1}{\hidepaste}
\tab{5}\spadcommand{)set functions cache 3 f g\bound{cache }}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCachePageEmpty1}
\begin{paste}{ugUserCachePageEmpty1}{ugUserCachePagePatch1}
\pastebutton{ugUserCachePageEmpty1}{\showpaste}
\tab{5}\spadcommand{)set functions cache 3 f g\bound{cache }}
\end{paste}\end{patch}

\begin{patch}{ugUserCachePagePatch2}
\begin{paste}{ugUserCachePageFull2}{ugUserCachePageEmpty2}
\pastebutton{ugUserCachePageFull2}{\hidepaste}
\tab{5}\spadcommand{f x == factorial(2^x)\bound{fdef }\free{cache }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCachePageEmpty2}
\begin{paste}{ugUserCachePageEmpty2}{ugUserCachePagePatch2}
\pastebutton{ugUserCachePageEmpty2}{\showpaste}
\tab{5}\spadcommand{f x == factorial(2^x)\bound{fdef }\free{cache }}
\end{paste}\end{patch}

\begin{patch}{ugUserCachePagePatch3}
\begin{paste}{ugUserCachePageFull3}{ugUserCachePageEmpty3}
\pastebutton{ugUserCachePageFull3}{\hidepaste}
\tab{5}\spadcommand{f(4)\free{cache }}
\indentrel{3}\begin{verbatim}
   (2)  20922789888000
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCachePageEmpty3}
\begin{paste}{ugUserCachePageEmpty3}{ugUserCachePagePatch3}
\pastebutton{ugUserCachePageEmpty3}{\showpaste}
\tab{5}\spadcommand{f(4)\free{cache }}
\end{paste}\end{patch}

\begin{patch}{ugUserCachePagePatch4}
\begin{paste}{ugUserCachePageFull4}{ugUserCachePageEmpty4}
\pastebutton{ugUserCachePageFull4}{\hidepaste}
\tab{5}\spadcommand{)set functions cache all}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCachePageEmpty4}
\begin{paste}{ugUserCachePageEmpty4}{ugUserCachePagePatch4}
\pastebutton{ugUserCachePageEmpty4}{\showpaste}
\tab{5}\spadcommand{)set functions cache all}
\end{paste}\end{patch}

\begin{patch}{ugUserCachePagePatch5}
\begin{paste}{ugUserCachePageFull5}{ugUserCachePageEmpty5}
\pastebutton{ugUserCachePageFull5}{\hidepaste}
\tab{5}\spadcommand{)set functions cache 0}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCachePageEmpty5}
\begin{paste}{ugUserCachePageEmpty5}{ugUserCachePagePatch5}
\pastebutton{ugUserCachePageEmpty5}{\showpaste}
\tab{5}\spadcommand{)set functions cache 0}
\end{paste}\end{patch}

\begin{patch}{ugUserCachePagePatch6}
\begin{paste}{ugUserCachePageFull6}{ugUserCachePageEmpty6}
\pastebutton{ugUserCachePageFull6}{\hidepaste}
\tab{5}\spadcommand{)set functions cache 0 f g}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCachePageEmpty6}
\begin{paste}{ugUserCachePageEmpty6}{ugUserCachePagePatch6}
\pastebutton{ugUserCachePageEmpty6}{\showpaste}
\tab{5}\spadcommand{)set functions cache 0 f g}
\end{paste}\end{patch}

\begin{patch}{ugUserDelayPagePatch1}
\begin{paste}{ugUserDelayPageFull1}{ugUserDelayPageEmpty1}
\pastebutton{ugUserDelayPageFull1}{\hidepaste}
\tab{5}\spadcommand{sin24() == sin(24.0)\bound{sin24 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDelayPageEmpty1}
\begin{paste}{ugUserDelayPageEmpty1}{ugUserDelayPagePatch1}
\pastebutton{ugUserDelayPageEmpty1}{\showpaste}
\tab{5}\spadcommand{sin24() == sin(24.0)\bound{sin24 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDelayPagePatch2}
\begin{paste}{ugUserDelayPageFull2}{ugUserDelayPageEmpty2}
\pastebutton{ugUserDelayPageFull2}{\hidepaste}
\tab{5}\spadcommand{sin24()\free{sin24 }}
\indentrel{3}\begin{verbatim}
   (2)  - 0.9055783620_0662384514
                                            Type: Float
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDelayPageEmpty2}
\begin{paste}{ugUserDelayPageEmpty2}{ugUserDelayPagePatch2}
\pastebutton{ugUserDelayPageEmpty2}{\showpaste}
\tab{5}\spadcommand{sin24()\free{sin24 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDelayPagePatch3}
\begin{paste}{ugUserDelayPageFull3}{ugUserDelayPageEmpty3}
\pastebutton{ugUserDelayPageFull3}{\hidepaste}
\tab{5}\spadcommand{sin24\free{sin24 }}
\indentrel{3}\begin{verbatim}
   (3)  sin24() == sin(24.0)
                            Type: FunctionCalled(sin24)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDelayPageEmpty3}
\begin{paste}{ugUserDelayPageEmpty3}{ugUserDelayPagePatch3}
\pastebutton{ugUserDelayPageEmpty3}{\showpaste}
\tab{5}\spadcommand{sin24\free{sin24 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDelayPagePatch4}
\begin{paste}{ugUserDelayPageFull4}{ugUserDelayPageEmpty4}
\pastebutton{ugUserDelayPageFull4}{\hidepaste}
\tab{5}\spadcommand{cos24 == cos(24.0)\bound{cos24 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDelayPageEmpty4}
\begin{paste}{ugUserDelayPageEmpty4}{ugUserDelayPagePatch4}
\pastebutton{ugUserDelayPageEmpty4}{\showpaste}
\tab{5}\spadcommand{cos24 == cos(24.0)\bound{cos24 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDelayPagePatch5}
\begin{paste}{ugUserDelayPageFull5}{ugUserDelayPageEmpty5}
\pastebutton{ugUserDelayPageFull5}{\hidepaste}
\tab{5}\spadcommand{cos24\free{cos24 }}
\indentrel{3}\begin{verbatim}
   (5)  0.4241790073_3699697594
                                            Type: Float
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDelayPageEmpty5}
\begin{paste}{ugUserDelayPageEmpty5}{ugUserDelayPagePatch5}
\pastebutton{ugUserDelayPageEmpty5}{\showpaste}
\tab{5}\spadcommand{cos24\free{cos24 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch1}
\begin{paste}{ugUserRecurPageFull1}{ugUserRecurPageEmpty1}
\pastebutton{ugUserRecurPageFull1}{\hidepaste}
\tab{5}\spadcommand{[fibonacci(i) for i in 0..]}
\indentrel{3}\begin{verbatim}
   (1)  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...]
                                  Type: Stream(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty1}
\begin{paste}{ugUserRecurPageEmpty1}{ugUserRecurPagePatch1}
\pastebutton{ugUserRecurPageEmpty1}{\showpaste}
\tab{5}\spadcommand{[fibonacci(i) for i in 0..]}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch2}
\begin{paste}{ugUserRecurPageFull2}{ugUserRecurPageEmpty2}
\pastebutton{ugUserRecurPageFull2}{\hidepaste}
\tab{5}\spadcommand{fib(1) == 1\bound{fib0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty2}
\begin{paste}{ugUserRecurPageEmpty2}{ugUserRecurPagePatch2}
\pastebutton{ugUserRecurPageEmpty2}{\showpaste}
\tab{5}\spadcommand{fib(1) == 1\bound{fib0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch3}
\begin{paste}{ugUserRecurPageFull3}{ugUserRecurPageEmpty3}
\pastebutton{ugUserRecurPageFull3}{\hidepaste}
\tab{5}\spadcommand{fib(2) == 1\bound{fib1 }\free{fib0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty3}
\begin{paste}{ugUserRecurPageEmpty3}{ugUserRecurPagePatch3}
\pastebutton{ugUserRecurPageEmpty3}{\showpaste}
\tab{5}\spadcommand{fib(2) == 1\bound{fib1 }\free{fib0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch4}
\begin{paste}{ugUserRecurPageFull4}{ugUserRecurPageEmpty4}
\pastebutton{ugUserRecurPageFull4}{\hidepaste}
\tab{5}\spadcommand{fib(n) == fib(n-1) + fib(n-2)\bound{fibn }\free{fib1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty4}
\begin{paste}{ugUserRecurPageEmpty4}{ugUserRecurPagePatch4}
\pastebutton{ugUserRecurPageEmpty4}{\showpaste}
\tab{5}\spadcommand{fib(n) == fib(n-1) + fib(n-2)\bound{fibn }\free{fib1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch5}
\begin{paste}{ugUserRecurPageFull5}{ugUserRecurPageEmpty5}
\pastebutton{ugUserRecurPageFull5}{\hidepaste}
\tab{5}\spadcommand{fib(500)\free{fibn }}
\indentrel{3}\begin{verbatim}
   (5)
  139423224561697880139724382870407283950070256587697307_
   264108962948325571622863290691557658876222521294125
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty5}
\begin{paste}{ugUserRecurPageEmpty5}{ugUserRecurPagePatch5}
\pastebutton{ugUserRecurPageEmpty5}{\showpaste}
\tab{5}\spadcommand{fib(500)\free{fibn }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch6}
\begin{paste}{ugUserRecurPageFull6}{ugUserRecurPageEmpty6}
\pastebutton{ugUserRecurPageFull6}{\hidepaste}
\tab{5}\spadcommand{p(0) == 1\bound{p0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty6}
\begin{paste}{ugUserRecurPageEmpty6}{ugUserRecurPagePatch6}
\pastebutton{ugUserRecurPageEmpty6}{\showpaste}
\tab{5}\spadcommand{p(0) == 1\bound{p0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch7}
\begin{paste}{ugUserRecurPageFull7}{ugUserRecurPageEmpty7}
\pastebutton{ugUserRecurPageFull7}{\hidepaste}
\tab{5}\spadcommand{p(1) == x\bound{p1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty7}
\begin{paste}{ugUserRecurPageEmpty7}{ugUserRecurPagePatch7}
\pastebutton{ugUserRecurPageEmpty7}{\showpaste}
\tab{5}\spadcommand{p(1) == x\bound{p1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch8}
\begin{paste}{ugUserRecurPageFull8}{ugUserRecurPageEmpty8}
\pastebutton{ugUserRecurPageFull8}{\hidepaste}
\tab{5}\spadcommand{p(n) == ((2*n-1)*x*p(n-1) - (n-1)*p(n-2))/n\bound{pn }\free{p1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty8}
\begin{paste}{ugUserRecurPageEmpty8}{ugUserRecurPagePatch8}
\pastebutton{ugUserRecurPageEmpty8}{\showpaste}
\tab{5}\spadcommand{p(n) == ((2*n-1)*x*p(n-1) - (n-1)*p(n-2))/n\bound{pn }\free{p1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRecurPagePatch9}
\begin{paste}{ugUserRecurPageFull9}{ugUserRecurPageEmpty9}
\pastebutton{ugUserRecurPageFull9}{\hidepaste}
\tab{5}\spadcommand{p(6)\free{pn }}
\indentrel{3}\begin{verbatim}
        231  6   315  4   105  2    5
   (9)  --- x  - --- x  + --- x  - --
         16       16       16      16
                    Type: Polynomial(Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRecurPageEmpty9}
\begin{paste}{ugUserRecurPageEmpty9}{ugUserRecurPagePatch9}
\pastebutton{ugUserRecurPageEmpty9}{\showpaste}
\tab{5}\spadcommand{p(6)\free{pn }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch1}
\begin{paste}{ugUserRulesPageFull1}{ugUserRulesPageEmpty1}
\pastebutton{ugUserRulesPageFull1}{\hidepaste}
\tab{5}\spadcommand{logrules := rule
  log(x) + log(y) == log(x * y)
  y * log x       == log(x ^ y)
\bound{logrules }}
\indentrel{3}\begin{verbatim}
   (1)
   {log(y) + log(x) + %B == log(x y) + %B,
                     y
    y log(x) == log(x )}
     Type: Ruleset(Integer,Integer,Expression(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty1}
\begin{paste}{ugUserRulesPageEmpty1}{ugUserRulesPagePatch1}
\pastebutton{ugUserRulesPageEmpty1}{\showpaste}
\tab{5}\spadcommand{logrules := rule
  log(x) + log(y) == log(x * y)
  y * log x       == log(x ^ y)
\bound{logrules }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch2}
\begin{paste}{ugUserRulesPageFull2}{ugUserRulesPageEmpty2}
\pastebutton{ugUserRulesPageFull2}{\hidepaste}
\tab{5}\spadcommand{f := a * log(sin x) - 2 * log x\bound{f1 }}
\indentrel{3}\begin{verbatim}
   (2)  a log(sin(x)) - 2 log(x)
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty2}
\begin{paste}{ugUserRulesPageEmpty2}{ugUserRulesPagePatch2}
\pastebutton{ugUserRulesPageEmpty2}{\showpaste}
\tab{5}\spadcommand{f := a * log(sin x) - 2 * log x\bound{f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch3}
\begin{paste}{ugUserRulesPageFull3}{ugUserRulesPageEmpty3}
\pastebutton{ugUserRulesPageFull3}{\hidepaste}
\tab{5}\spadcommand{logrules f\free{f1 }\free{logrules }}
\indentrel{3}\begin{verbatim}
                  a
            sin(x)
   (3)  log(-------)
                2
               x
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty3}
\begin{paste}{ugUserRulesPageEmpty3}{ugUserRulesPagePatch3}
\pastebutton{ugUserRulesPageEmpty3}{\showpaste}
\tab{5}\spadcommand{logrules f\free{f1 }\free{logrules }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch4}
\begin{paste}{ugUserRulesPageFull4}{ugUserRulesPageEmpty4}
\pastebutton{ugUserRulesPageFull4}{\hidepaste}
\tab{5}\spadcommand{logrules2 := rule
  log(x) + log(y)          == log(x * y)
  (y | integer? y) * log x == log(x ^ y)
\bound{logrules2 }}
\indentrel{3}\begin{verbatim}
   (4)
   {log(y) + log(x) + %D == log(x y) + %D,
                     y
    y log(x) == log(x )}
     Type: Ruleset(Integer,Integer,Expression(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty4}
\begin{paste}{ugUserRulesPageEmpty4}{ugUserRulesPagePatch4}
\pastebutton{ugUserRulesPageEmpty4}{\showpaste}
\tab{5}\spadcommand{logrules2 := rule
  log(x) + log(y)          == log(x * y)
  (y | integer? y) * log x == log(x ^ y)
\bound{logrules2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch5}
\begin{paste}{ugUserRulesPageFull5}{ugUserRulesPageEmpty5}
\pastebutton{ugUserRulesPageFull5}{\hidepaste}
\tab{5}\spadcommand{f\free{f1 }}
\indentrel{3}\begin{verbatim}
   (5)  a log(sin(x)) - 2 log(x)
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty5}
\begin{paste}{ugUserRulesPageEmpty5}{ugUserRulesPagePatch5}
\pastebutton{ugUserRulesPageEmpty5}{\showpaste}
\tab{5}\spadcommand{f\free{f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch6}
\begin{paste}{ugUserRulesPageFull6}{ugUserRulesPageEmpty6}
\pastebutton{ugUserRulesPageFull6}{\hidepaste}
\tab{5}\spadcommand{logrules2 f\free{f1 }\free{logrules2 }}
\indentrel{3}\begin{verbatim}
                             1
   (6)  a log(sin(x)) + log(--)
                             2
                            x
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty6}
\begin{paste}{ugUserRulesPageEmpty6}{ugUserRulesPagePatch6}
\pastebutton{ugUserRulesPageEmpty6}{\showpaste}
\tab{5}\spadcommand{logrules2 f\free{f1 }\free{logrules2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch7}
\begin{paste}{ugUserRulesPageFull7}{ugUserRulesPageEmpty7}
\pastebutton{ugUserRulesPageFull7}{\hidepaste}
\tab{5}\spadcommand{evenRule := rule cos(x)^(n | integer? n and even? integer n)==(1-sin(x)^2)^(n/2)\bound{evenRule }}
\indentrel{3}\begin{verbatim}
                                  n
                                  -
              n             2     2
   (7)  cos(x)  == (- sin(x)  + 1)
 Type: RewriteRule(Integer,Integer,Expression(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty7}
\begin{paste}{ugUserRulesPageEmpty7}{ugUserRulesPagePatch7}
\pastebutton{ugUserRulesPageEmpty7}{\showpaste}
\tab{5}\spadcommand{evenRule := rule cos(x)^(n | integer? n and even? integer n)==(1-sin(x)^2)^(n/2)\bound{evenRule }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch8}
\begin{paste}{ugUserRulesPageFull8}{ugUserRulesPageEmpty8}
\pastebutton{ugUserRulesPageFull8}{\hidepaste}
\tab{5}\spadcommand{evenRule( cos(x)^2 )\free{evenRule }}
\indentrel{3}\begin{verbatim}
                2
   (8)  - sin(x)  + 1
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty8}
\begin{paste}{ugUserRulesPageEmpty8}{ugUserRulesPagePatch8}
\pastebutton{ugUserRulesPageEmpty8}{\showpaste}
\tab{5}\spadcommand{evenRule( cos(x)^2 )\free{evenRule }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch9}
\begin{paste}{ugUserRulesPageFull9}{ugUserRulesPageEmpty9}
\pastebutton{ugUserRulesPageFull9}{\hidepaste}
\tab{5}\spadcommand{sinCosProducts == rule
  sin(x) * sin(y) == (cos(x-y) - cos(x + y))/2
  cos(x) * cos(y) == (cos(x-y) + cos(x+y))/2
  sin(x) * cos(y) == (sin(x-y) + sin(x + y))/2
\bound{sinCosProducts }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty9}
\begin{paste}{ugUserRulesPageEmpty9}{ugUserRulesPagePatch9}
\pastebutton{ugUserRulesPageEmpty9}{\showpaste}
\tab{5}\spadcommand{sinCosProducts == rule
  sin(x) * sin(y) == (cos(x-y) - cos(x + y))/2
  cos(x) * cos(y) == (cos(x-y) + cos(x+y))/2
  sin(x) * cos(y) == (sin(x-y) + sin(x + y))/2
\bound{sinCosProducts }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch10}
\begin{paste}{ugUserRulesPageFull10}{ugUserRulesPageEmpty10}
\pastebutton{ugUserRulesPageFull10}{\hidepaste}
\tab{5}\spadcommand{g := sin(a)*sin(b) + cos(b)*cos(a) + sin(2*a)*cos(2*a)\bound{g }}
\indentrel{3}\begin{verbatim}
   (10)  sin(a)sin(b) + cos(2 a)sin(2 a) + cos(a)cos(b)
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty10}
\begin{paste}{ugUserRulesPageEmpty10}{ugUserRulesPagePatch10}
\pastebutton{ugUserRulesPageEmpty10}{\showpaste}
\tab{5}\spadcommand{g := sin(a)*sin(b) + cos(b)*cos(a) + sin(2*a)*cos(2*a)\bound{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch11}
\begin{paste}{ugUserRulesPageFull11}{ugUserRulesPageEmpty11}
\pastebutton{ugUserRulesPageFull11}{\hidepaste}
\tab{5}\spadcommand{sinCosProducts g\free{sinCosProducts g }}
\indentrel{3}\begin{verbatim}
         sin(4 a) + 2 cos(b - a)
   (11)  -----------------------
                    2
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty11}
\begin{paste}{ugUserRulesPageEmpty11}{ugUserRulesPagePatch11}
\pastebutton{ugUserRulesPageEmpty11}{\showpaste}
\tab{5}\spadcommand{sinCosProducts g\free{sinCosProducts g }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch12}
\begin{paste}{ugUserRulesPageFull12}{ugUserRulesPageEmpty12}
\pastebutton{ugUserRulesPageFull12}{\hidepaste}
\tab{5}\spadcommand{exprule := rule exp(a + b) == exp(a) * exp(b)\bound{exprule }}
\indentrel{3}\begin{verbatim}
           b + a      a  b
   (12)  %e      == %e %e
 Type: RewriteRule(Integer,Integer,Expression(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty12}
\begin{paste}{ugUserRulesPageEmpty12}{ugUserRulesPagePatch12}
\pastebutton{ugUserRulesPageEmpty12}{\showpaste}
\tab{5}\spadcommand{exprule := rule exp(a + b) == exp(a) * exp(b)\bound{exprule }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch13}
\begin{paste}{ugUserRulesPageFull13}{ugUserRulesPageEmpty13}
\pastebutton{ugUserRulesPageFull13}{\hidepaste}
\tab{5}\spadcommand{exprule exp x\free{exprule }}
\indentrel{3}\begin{verbatim}
           x
   (13)  %e
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty13}
\begin{paste}{ugUserRulesPageEmpty13}{ugUserRulesPagePatch13}
\pastebutton{ugUserRulesPageEmpty13}{\showpaste}
\tab{5}\spadcommand{exprule exp x\free{exprule }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch14}
\begin{paste}{ugUserRulesPageFull14}{ugUserRulesPageEmpty14}
\pastebutton{ugUserRulesPageFull14}{\hidepaste}
\tab{5}\spadcommand{eirule := rule integral((?y + exp x)/x,x) == integral(y/x,x) + Ei x\bound{eirule }}
\indentrel{3}\begin{verbatim}
            x   %C                x
          ++  %e   + y          ++   y
   (14)   |   -------- d%C  ==  |   -- d%C  + Ei(x)
         ++      %C            ++   %C
 Type: RewriteRule(Integer,Integer,Expression(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty14}
\begin{paste}{ugUserRulesPageEmpty14}{ugUserRulesPagePatch14}
\pastebutton{ugUserRulesPageEmpty14}{\showpaste}
\tab{5}\spadcommand{eirule := rule integral((?y + exp x)/x,x) == integral(y/x,x) + Ei x\bound{eirule }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch15}
\begin{paste}{ugUserRulesPageFull15}{ugUserRulesPageEmpty15}
\pastebutton{ugUserRulesPageFull15}{\hidepaste}
\tab{5}\spadcommand{eirule integral(exp u/u, u)\free{eirule }}
\indentrel{3}\begin{verbatim}
   (15)  Ei(u)
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty15}
\begin{paste}{ugUserRulesPageEmpty15}{ugUserRulesPagePatch15}
\pastebutton{ugUserRulesPageEmpty15}{\showpaste}
\tab{5}\spadcommand{eirule integral(exp u/u, u)\free{eirule }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch16}
\begin{paste}{ugUserRulesPageFull16}{ugUserRulesPageEmpty16}
\pastebutton{ugUserRulesPageFull16}{\hidepaste}
\tab{5}\spadcommand{eirule integral((sin u + exp u)/u, u)\free{eirule }}
\indentrel{3}\begin{verbatim}
            u
          ++  sin(%C)
   (16)   |   ------- d%C  + Ei(u)
         ++      %C
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty16}
\begin{paste}{ugUserRulesPageEmpty16}{ugUserRulesPagePatch16}
\pastebutton{ugUserRulesPageEmpty16}{\showpaste}
\tab{5}\spadcommand{eirule integral((sin u + exp u)/u, u)\free{eirule }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch17}
\begin{paste}{ugUserRulesPageFull17}{ugUserRulesPageEmpty17}
\pastebutton{ugUserRulesPageFull17}{\hidepaste}
\tab{5}\spadcommand{u := operator 'u\bound{u }}
\indentrel{3}\begin{verbatim}
   (17)  u
                                    Type: BasicOperator
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty17}
\begin{paste}{ugUserRulesPageEmpty17}{ugUserRulesPagePatch17}
\pastebutton{ugUserRulesPageEmpty17}{\showpaste}
\tab{5}\spadcommand{u := operator 'u\bound{u }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch18}
\begin{paste}{ugUserRulesPageFull18}{ugUserRulesPageEmpty18}
\pastebutton{ugUserRulesPageFull18}{\hidepaste}
\tab{5}\spadcommand{v := operator 'v\bound{v }}
\indentrel{3}\begin{verbatim}
   (18)  v
                                    Type: BasicOperator
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty18}
\begin{paste}{ugUserRulesPageEmpty18}{ugUserRulesPagePatch18}
\pastebutton{ugUserRulesPageEmpty18}{\showpaste}
\tab{5}\spadcommand{v := operator 'v\bound{v }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch19}
\begin{paste}{ugUserRulesPageFull19}{ugUserRulesPageEmpty19}
\pastebutton{ugUserRulesPageFull19}{\hidepaste}
\tab{5}\spadcommand{myRule := rule u(x + y) == u x + v y\free{u v }\bound{m }}
\indentrel{3}\begin{verbatim}
   (19)  u(y + x) == v(y) + u(x)
 Type: RewriteRule(Integer,Integer,Expression(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty19}
\begin{paste}{ugUserRulesPageEmpty19}{ugUserRulesPagePatch19}
\pastebutton{ugUserRulesPageEmpty19}{\showpaste}
\tab{5}\spadcommand{myRule := rule u(x + y) == u x + v y\free{u v }\bound{m }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch20}
\begin{paste}{ugUserRulesPageFull20}{ugUserRulesPageEmpty20}
\pastebutton{ugUserRulesPageFull20}{\hidepaste}
\tab{5}\spadcommand{myRule u(a + b + c + d)\free{m }}
\indentrel{3}\begin{verbatim}
   (20)  v(c + b + a) + u(d)
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty20}
\begin{paste}{ugUserRulesPageEmpty20}{ugUserRulesPagePatch20}
\pastebutton{ugUserRulesPageEmpty20}{\showpaste}
\tab{5}\spadcommand{myRule u(a + b + c + d)\free{m }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch21}
\begin{paste}{ugUserRulesPageFull21}{ugUserRulesPageEmpty21}
\pastebutton{ugUserRulesPageFull21}{\hidepaste}
\tab{5}\spadcommand{myOtherRule := rule u(:x + y) == u x + v y\free{u v }\bound{m2 }}
\indentrel{3}\begin{verbatim}
   (21)  u(y + x) == v(y) + u(x)
 Type: RewriteRule(Integer,Integer,Expression(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty21}
\begin{paste}{ugUserRulesPageEmpty21}{ugUserRulesPagePatch21}
\pastebutton{ugUserRulesPageEmpty21}{\showpaste}
\tab{5}\spadcommand{myOtherRule := rule u(:x + y) == u x + v y\free{u v }\bound{m2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserRulesPagePatch22}
\begin{paste}{ugUserRulesPageFull22}{ugUserRulesPageEmpty22}
\pastebutton{ugUserRulesPageFull22}{\hidepaste}
\tab{5}\spadcommand{myOtherRule u(a + b + c + d)\free{m2 }}
\indentrel{3}\begin{verbatim}
   (22)  v(d) + v(c) + v(b) + u(a)
                              Type: Expression(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserRulesPageEmpty22}
\begin{paste}{ugUserRulesPageEmpty22}{ugUserRulesPagePatch22}
\pastebutton{ugUserRulesPageEmpty22}{\showpaste}
\tab{5}\spadcommand{myOtherRule u(a + b + c + d)\free{m2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserIntroPagePatch1}
\begin{paste}{ugUserIntroPageFull1}{ugUserIntroPageEmpty1}
\pastebutton{ugUserIntroPageFull1}{\hidepaste}
\tab{5}\spadcommand{factor(12)}
\indentrel{3}\begin{verbatim}
         2
   (1)  2 3
                                Type: Factored(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserIntroPageEmpty1}
\begin{paste}{ugUserIntroPageEmpty1}{ugUserIntroPagePatch1}
\pastebutton{ugUserIntroPageEmpty1}{\showpaste}
\tab{5}\spadcommand{factor(12)}
\end{paste}\end{patch}

\begin{patch}{ugUserIntroPagePatch2}
\begin{paste}{ugUserIntroPageFull2}{ugUserIntroPageEmpty2}
\pastebutton{ugUserIntroPageFull2}{\hidepaste}
\tab{5}\spadcommand{3 + 4}
\indentrel{3}\begin{verbatim}
   (2)  7
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserIntroPageEmpty2}
\begin{paste}{ugUserIntroPageEmpty2}{ugUserIntroPagePatch2}
\pastebutton{ugUserIntroPageEmpty2}{\showpaste}
\tab{5}\spadcommand{3 + 4}
\end{paste}\end{patch}

\begin{patch}{ugUserIntroPagePatch3}
\begin{paste}{ugUserIntroPageFull3}{ugUserIntroPageEmpty3}
\pastebutton{ugUserIntroPageFull3}{\hidepaste}
\tab{5}\spadcommand{1 + 2 + 7}
\indentrel{3}\begin{verbatim}
   (3)  10
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserIntroPageEmpty3}
\begin{paste}{ugUserIntroPageEmpty3}{ugUserIntroPagePatch3}
\pastebutton{ugUserIntroPageEmpty3}{\showpaste}
\tab{5}\spadcommand{1 + 2 + 7}
\end{paste}\end{patch}

\begin{patch}{ugUserFunMacPagePatch1}
\begin{paste}{ugUserFunMacPageFull1}{ugUserFunMacPageEmpty1}
\pastebutton{ugUserFunMacPageFull1}{\hidepaste}
\tab{5}\spadcommand{abs(-8)}
\indentrel{3}\begin{verbatim}
   (1)  8
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFunMacPageEmpty1}
\begin{paste}{ugUserFunMacPageEmpty1}{ugUserFunMacPagePatch1}
\pastebutton{ugUserFunMacPageEmpty1}{\showpaste}
\tab{5}\spadcommand{abs(-8)}
\end{paste}\end{patch}

\begin{patch}{ugUserFunMacPagePatch2}
\begin{paste}{ugUserFunMacPageFull2}{ugUserFunMacPageEmpty2}
\pastebutton{ugUserFunMacPageFull2}{\hidepaste}
\tab{5}\spadcommand{(x +-> if x < 0 then -x else x)(-8)}
\indentrel{3}\begin{verbatim}
   (2)  8
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFunMacPageEmpty2}
\begin{paste}{ugUserFunMacPageEmpty2}{ugUserFunMacPagePatch2}
\pastebutton{ugUserFunMacPageEmpty2}{\showpaste}
\tab{5}\spadcommand{(x +-> if x < 0 then -x else x)(-8)}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch1}
\begin{paste}{ugUserBlocksPageFull1}{ugUserBlocksPageEmpty1}
\pastebutton{ugUserBlocksPageFull1}{\hidepaste}
\tab{5}\spadcommand{swap(m,i,j) ==
  temp := m.i
  m.i := m.j
  m.j := temp
\bound{swap }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty1}
\begin{paste}{ugUserBlocksPageEmpty1}{ugUserBlocksPagePatch1}
\pastebutton{ugUserBlocksPageEmpty1}{\showpaste}
\tab{5}\spadcommand{swap(m,i,j) ==
  temp := m.i
  m.i := m.j
  m.j := temp
\bound{swap }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch2}
\begin{paste}{ugUserBlocksPageFull2}{ugUserBlocksPageEmpty2}
\pastebutton{ugUserBlocksPageFull2}{\hidepaste}
\tab{5}\spadcommand{k := [1,2,3,4,5]\bound{k }}
\indentrel{3}\begin{verbatim}
   (2)  [1, 2, 3, 4, 5]
                            Type: List(PositiveInteger)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty2}
\begin{paste}{ugUserBlocksPageEmpty2}{ugUserBlocksPagePatch2}
\pastebutton{ugUserBlocksPageEmpty2}{\showpaste}
\tab{5}\spadcommand{k := [1,2,3,4,5]\bound{k }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch3}
\begin{paste}{ugUserBlocksPageFull3}{ugUserBlocksPageEmpty3}
\pastebutton{ugUserBlocksPageFull3}{\hidepaste}
\tab{5}\spadcommand{swap(k,2,4)\free{l swap }\bound{swapk }}
\indentrel{3}\begin{verbatim}
   (3)  2
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty3}
\begin{paste}{ugUserBlocksPageEmpty3}{ugUserBlocksPagePatch3}
\pastebutton{ugUserBlocksPageEmpty3}{\showpaste}
\tab{5}\spadcommand{swap(k,2,4)\free{l swap }\bound{swapk }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch4}
\begin{paste}{ugUserBlocksPageFull4}{ugUserBlocksPageEmpty4}
\pastebutton{ugUserBlocksPageFull4}{\hidepaste}
\tab{5}\spadcommand{k\free{swapk }}
\indentrel{3}\begin{verbatim}
   (4)  [1, 4, 3, 2, 5]
                            Type: List(PositiveInteger)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty4}
\begin{paste}{ugUserBlocksPageEmpty4}{ugUserBlocksPagePatch4}
\pastebutton{ugUserBlocksPageEmpty4}{\showpaste}
\tab{5}\spadcommand{k\free{swapk }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch5}
\begin{paste}{ugUserBlocksPageFull5}{ugUserBlocksPageEmpty5}
\pastebutton{ugUserBlocksPageFull5}{\hidepaste}
\tab{5}\spadcommand{bubbleSort(m) ==
  n := \#m
  for i in 1..(n-1) repeat
    for j in n..(i+1) by -1 repeat
      if m.j < m.(j-1) then swap(m,j,j-1)
  m
\bound{bubbleSort }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty5}
\begin{paste}{ugUserBlocksPageEmpty5}{ugUserBlocksPagePatch5}
\pastebutton{ugUserBlocksPageEmpty5}{\showpaste}
\tab{5}\spadcommand{bubbleSort(m) ==
  n := \#m
  for i in 1..(n-1) repeat
    for j in n..(i+1) by -1 repeat
      if m.j < m.(j-1) then swap(m,j,j-1)
  m
\bound{bubbleSort }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch6}
\begin{paste}{ugUserBlocksPageFull6}{ugUserBlocksPageEmpty6}
\pastebutton{ugUserBlocksPageFull6}{\hidepaste}
\tab{5}\spadcommand{m := [8,4,-3,9]\bound{m }}
\indentrel{3}\begin{verbatim}
   (6)  [8, 4, - 3, 9]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty6}
\begin{paste}{ugUserBlocksPageEmpty6}{ugUserBlocksPagePatch6}
\pastebutton{ugUserBlocksPageEmpty6}{\showpaste}
\tab{5}\spadcommand{m := [8,4,-3,9]\bound{m }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch7}
\begin{paste}{ugUserBlocksPageFull7}{ugUserBlocksPageEmpty7}
\pastebutton{ugUserBlocksPageFull7}{\hidepaste}
\tab{5}\spadcommand{bubbleSort(m)\free{m swap bubbleSort }\bound{sortm }}
\indentrel{3}\begin{verbatim}
   (7)  [- 3, 4, 8, 9]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty7}
\begin{paste}{ugUserBlocksPageEmpty7}{ugUserBlocksPagePatch7}
\pastebutton{ugUserBlocksPageEmpty7}{\showpaste}
\tab{5}\spadcommand{bubbleSort(m)\free{m swap bubbleSort }\bound{sortm }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch8}
\begin{paste}{ugUserBlocksPageFull8}{ugUserBlocksPageEmpty8}
\pastebutton{ugUserBlocksPageFull8}{\hidepaste}
\tab{5}\spadcommand{m\free{sortm }}
\indentrel{3}\begin{verbatim}
   (8)  [- 3, 4, 8, 9]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty8}
\begin{paste}{ugUserBlocksPageEmpty8}{ugUserBlocksPagePatch8}
\pastebutton{ugUserBlocksPageEmpty8}{\showpaste}
\tab{5}\spadcommand{m\free{sortm }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch9}
\begin{paste}{ugUserBlocksPageFull9}{ugUserBlocksPageEmpty9}
\pastebutton{ugUserBlocksPageFull9}{\hidepaste}
\tab{5}\spadcommand{insertionSort(m) ==
  for i in 2..\#m repeat
    j := i
    while j > 1 and m.j < m.(j-1) repeat
      swap(m,j,j-1)
      j := j - 1
  m
\bound{insertionSort }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty9}
\begin{paste}{ugUserBlocksPageEmpty9}{ugUserBlocksPagePatch9}
\pastebutton{ugUserBlocksPageEmpty9}{\showpaste}
\tab{5}\spadcommand{insertionSort(m) ==
  for i in 2..\#m repeat
    j := i
    while j > 1 and m.j < m.(j-1) repeat
      swap(m,j,j-1)
      j := j - 1
  m
\bound{insertionSort }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch10}
\begin{paste}{ugUserBlocksPageFull10}{ugUserBlocksPageEmpty10}
\pastebutton{ugUserBlocksPageFull10}{\hidepaste}
\tab{5}\spadcommand{m := [8,4,-3,9]\bound{m1 }}
\indentrel{3}\begin{verbatim}
   (10)  [8, 4, - 3, 9]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty10}
\begin{paste}{ugUserBlocksPageEmpty10}{ugUserBlocksPagePatch10}
\pastebutton{ugUserBlocksPageEmpty10}{\showpaste}
\tab{5}\spadcommand{m := [8,4,-3,9]\bound{m1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch11}
\begin{paste}{ugUserBlocksPageFull11}{ugUserBlocksPageEmpty11}
\pastebutton{ugUserBlocksPageFull11}{\hidepaste}
\tab{5}\spadcommand{insertionSort(m)\free{m1 swap insertionSort }\bound{sortm1 }}
\indentrel{3}\begin{verbatim}
   (11)  [- 3, 4, 8, 9]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty11}
\begin{paste}{ugUserBlocksPageEmpty11}{ugUserBlocksPagePatch11}
\pastebutton{ugUserBlocksPageEmpty11}{\showpaste}
\tab{5}\spadcommand{insertionSort(m)\free{m1 swap insertionSort }\bound{sortm1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch12}
\begin{paste}{ugUserBlocksPageFull12}{ugUserBlocksPageEmpty12}
\pastebutton{ugUserBlocksPageFull12}{\hidepaste}
\tab{5}\spadcommand{m\free{sortm1 }}
\indentrel{3}\begin{verbatim}
   (12)  [- 3, 4, 8, 9]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty12}
\begin{paste}{ugUserBlocksPageEmpty12}{ugUserBlocksPagePatch12}
\pastebutton{ugUserBlocksPageEmpty12}{\showpaste}
\tab{5}\spadcommand{m\free{sortm1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch13}
\begin{paste}{ugUserBlocksPageFull13}{ugUserBlocksPageEmpty13}
\pastebutton{ugUserBlocksPageFull13}{\hidepaste}
\tab{5}\spadcommand{bubbleSort2(m: List Integer): List Integer ==
  empty?(m) => m
  l := m
  while not empty?(r := l.rest) repeat
     r := bubbleSort2 r
     x := l.first
     if x < r.first then
       l.first := r.first
       r.first := x
     l.rest := r
     l := l.rest
  m
\bound{bubbleSort2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty13}
\begin{paste}{ugUserBlocksPageEmpty13}{ugUserBlocksPagePatch13}
\pastebutton{ugUserBlocksPageEmpty13}{\showpaste}
\tab{5}\spadcommand{bubbleSort2(m: List Integer): List Integer ==
  empty?(m) => m
  l := m
  while not empty?(r := l.rest) repeat
     r := bubbleSort2 r
     x := l.first
     if x < r.first then
       l.first := r.first
       r.first := x
     l.rest := r
     l := l.rest
  m
\bound{bubbleSort2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPagePatch14}
\begin{paste}{ugUserBlocksPageFull14}{ugUserBlocksPageEmpty14}
\pastebutton{ugUserBlocksPageFull14}{\hidepaste}
\tab{5}\spadcommand{bubbleSort2 [3,7,2]\free{bubbleSort2 }}
\indentrel{3}\begin{verbatim}
   (14)  [7, 3, 2]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserBlocksPageEmpty14}
\begin{paste}{ugUserBlocksPageEmpty14}{ugUserBlocksPagePatch14}
\pastebutton{ugUserBlocksPageEmpty14}{\showpaste}
\tab{5}\spadcommand{bubbleSort2 [3,7,2]\free{bubbleSort2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch1}
\begin{paste}{ugUserMacrosPageFull1}{ugUserMacrosPageEmpty1}
\pastebutton{ugUserMacrosPageFull1}{\hidepaste}
\tab{5}\spadcommand{macro df == D\bound{df }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty1}
\begin{paste}{ugUserMacrosPageEmpty1}{ugUserMacrosPagePatch1}
\pastebutton{ugUserMacrosPageEmpty1}{\showpaste}
\tab{5}\spadcommand{macro df == D\bound{df }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch2}
\begin{paste}{ugUserMacrosPageFull2}{ugUserMacrosPageEmpty2}
\pastebutton{ugUserMacrosPageFull2}{\hidepaste}
\tab{5}\spadcommand{df(x^2 + x + 1,x)\free{df }}
\indentrel{3}\begin{verbatim}
   (2)  2 x + 1
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty2}
\begin{paste}{ugUserMacrosPageEmpty2}{ugUserMacrosPagePatch2}
\pastebutton{ugUserMacrosPageEmpty2}{\showpaste}
\tab{5}\spadcommand{df(x^2 + x + 1,x)\free{df }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch3}
\begin{paste}{ugUserMacrosPageFull3}{ugUserMacrosPageEmpty3}
\pastebutton{ugUserMacrosPageFull3}{\hidepaste}
\tab{5}\spadcommand{macro ff(x) == x^2 + 1\bound{ff }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty3}
\begin{paste}{ugUserMacrosPageEmpty3}{ugUserMacrosPagePatch3}
\pastebutton{ugUserMacrosPageEmpty3}{\showpaste}
\tab{5}\spadcommand{macro ff(x) == x^2 + 1\bound{ff }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch4}
\begin{paste}{ugUserMacrosPageFull4}{ugUserMacrosPageEmpty4}
\pastebutton{ugUserMacrosPageFull4}{\hidepaste}
\tab{5}\spadcommand{ff z\free{ff }}
\indentrel{3}\begin{verbatim}
         2
   (4)  z  + 1
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty4}
\begin{paste}{ugUserMacrosPageEmpty4}{ugUserMacrosPagePatch4}
\pastebutton{ugUserMacrosPageEmpty4}{\showpaste}
\tab{5}\spadcommand{ff z\free{ff }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch5}
\begin{paste}{ugUserMacrosPageFull5}{ugUserMacrosPageEmpty5}
\pastebutton{ugUserMacrosPageFull5}{\hidepaste}
\tab{5}\spadcommand{macro gg(x) == ff(2*x - 2/3)\bound{gg }\free{ff }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty5}
\begin{paste}{ugUserMacrosPageEmpty5}{ugUserMacrosPagePatch5}
\pastebutton{ugUserMacrosPageEmpty5}{\showpaste}
\tab{5}\spadcommand{macro gg(x) == ff(2*x - 2/3)\bound{gg }\free{ff }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch6}
\begin{paste}{ugUserMacrosPageFull6}{ugUserMacrosPageEmpty6}
\pastebutton{ugUserMacrosPageFull6}{\hidepaste}
\tab{5}\spadcommand{gg(1/w)\free{gg }}
\indentrel{3}\begin{verbatim}
            2
        13 w  - 24 w + 36
   (6)  -----------------
                  2
               9 w
                    Type: Fraction(Polynomial(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty6}
\begin{paste}{ugUserMacrosPageEmpty6}{ugUserMacrosPagePatch6}
\pastebutton{ugUserMacrosPageEmpty6}{\showpaste}
\tab{5}\spadcommand{gg(1/w)\free{gg }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch7}
\begin{paste}{ugUserMacrosPageFull7}{ugUserMacrosPageEmpty7}
\pastebutton{ugUserMacrosPageFull7}{\hidepaste}
\tab{5}\spadcommand{macro ff(x) == gg(-x)\free{gg }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty7}
\begin{paste}{ugUserMacrosPageEmpty7}{ugUserMacrosPagePatch7}
\pastebutton{ugUserMacrosPageEmpty7}{\showpaste}
\tab{5}\spadcommand{macro ff(x) == gg(-x)\free{gg }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch8}
\begin{paste}{ugUserMacrosPageFull8}{ugUserMacrosPageEmpty8}
\pastebutton{ugUserMacrosPageFull8}{\hidepaste}
\tab{5}\spadcommand{macro next == (past := present; present := future; future := past + present)\bound{next }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty8}
\begin{paste}{ugUserMacrosPageEmpty8}{ugUserMacrosPagePatch8}
\pastebutton{ugUserMacrosPageEmpty8}{\showpaste}
\tab{5}\spadcommand{macro next == (past := present; present := future; future := past + present)\bound{next }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch9}
\begin{paste}{ugUserMacrosPageFull9}{ugUserMacrosPageEmpty9}
\pastebutton{ugUserMacrosPageFull9}{\hidepaste}
\tab{5}\spadcommand{present : Integer := 0\bound{present }}
\indentrel{3}\begin{verbatim}
   (9)  0
                                          Type: Integer
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty9}
\begin{paste}{ugUserMacrosPageEmpty9}{ugUserMacrosPagePatch9}
\pastebutton{ugUserMacrosPageEmpty9}{\showpaste}
\tab{5}\spadcommand{present : Integer := 0\bound{present }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch10}
\begin{paste}{ugUserMacrosPageFull10}{ugUserMacrosPageEmpty10}
\pastebutton{ugUserMacrosPageFull10}{\hidepaste}
\tab{5}\spadcommand{future : Integer := 1\bound{future }}
\indentrel{3}\begin{verbatim}
   (10)  1
                                          Type: Integer
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty10}
\begin{paste}{ugUserMacrosPageEmpty10}{ugUserMacrosPagePatch10}
\pastebutton{ugUserMacrosPageEmpty10}{\showpaste}
\tab{5}\spadcommand{future : Integer := 1\bound{future }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch11}
\begin{paste}{ugUserMacrosPageFull11}{ugUserMacrosPageEmpty11}
\pastebutton{ugUserMacrosPageFull11}{\hidepaste}
\tab{5}\spadcommand{next\free{future }\free{present }}
\indentrel{3}\begin{verbatim}
   (11)  1
                                          Type: Integer
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty11}
\begin{paste}{ugUserMacrosPageEmpty11}{ugUserMacrosPagePatch11}
\pastebutton{ugUserMacrosPageEmpty11}{\showpaste}
\tab{5}\spadcommand{next\free{future }\free{present }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch12}
\begin{paste}{ugUserMacrosPageFull12}{ugUserMacrosPageEmpty12}
\pastebutton{ugUserMacrosPageFull12}{\hidepaste}
\tab{5}\spadcommand{next\free{future }\free{present }}
\indentrel{3}\begin{verbatim}
   (12)  2
                                          Type: Integer
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty12}
\begin{paste}{ugUserMacrosPageEmpty12}{ugUserMacrosPagePatch12}
\pastebutton{ugUserMacrosPageEmpty12}{\showpaste}
\tab{5}\spadcommand{next\free{future }\free{present }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch13}
\begin{paste}{ugUserMacrosPageFull13}{ugUserMacrosPageEmpty13}
\pastebutton{ugUserMacrosPageFull13}{\hidepaste}
\tab{5}\spadcommand{[next for i in 1..]\free{future }\free{present }}
\indentrel{3}\begin{verbatim}
   (13)  [3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ...]
                                  Type: Stream(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty13}
\begin{paste}{ugUserMacrosPageEmpty13}{ugUserMacrosPagePatch13}
\pastebutton{ugUserMacrosPageEmpty13}{\showpaste}
\tab{5}\spadcommand{[next for i in 1..]\free{future }\free{present }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch14}
\begin{paste}{ugUserMacrosPageFull14}{ugUserMacrosPageEmpty14}
\pastebutton{ugUserMacrosPageFull14}{\hidepaste}
\tab{5}\spadcommand{macro fibStream ==
  present : Integer := 1
  future : Integer := 1
  [next for i in 1..] where
    macro next ==
      past := present
      present := future
      future := past + present
\bound{fibstr }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty14}
\begin{paste}{ugUserMacrosPageEmpty14}{ugUserMacrosPagePatch14}
\pastebutton{ugUserMacrosPageEmpty14}{\showpaste}
\tab{5}\spadcommand{macro fibStream ==
  present : Integer := 1
  future : Integer := 1
  [next for i in 1..] where
    macro next ==
      past := present
      present := future
      future := past + present
\bound{fibstr }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch15}
\begin{paste}{ugUserMacrosPageFull15}{ugUserMacrosPageEmpty15}
\pastebutton{ugUserMacrosPageFull15}{\hidepaste}
\tab{5}\spadcommand{concat([1,1],fibStream)\free{fibstr }}
\indentrel{3}\begin{verbatim}
   (15)  [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...]
                                  Type: Stream(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty15}
\begin{paste}{ugUserMacrosPageEmpty15}{ugUserMacrosPagePatch15}
\pastebutton{ugUserMacrosPageEmpty15}{\showpaste}
\tab{5}\spadcommand{concat([1,1],fibStream)\free{fibstr }}
\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPagePatch16}
\begin{paste}{ugUserMacrosPageFull16}{ugUserMacrosPageEmpty16}
\pastebutton{ugUserMacrosPageFull16}{\hidepaste}
\tab{5}\spadcommand{[fibonacci i for i in 1..]}
\indentrel{3}\begin{verbatim}
   (16)  [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...]
                                  Type: Stream(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserMacrosPageEmpty16}
\begin{paste}{ugUserMacrosPageEmpty16}{ugUserMacrosPagePatch16}
\pastebutton{ugUserMacrosPageEmpty16}{\showpaste}
\tab{5}\spadcommand{[fibonacci i for i in 1..]}
\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePagePatch1}
\begin{paste}{ugUserDeclarePageFull1}{ugUserDeclarePageEmpty1}
\pastebutton{ugUserDeclarePageFull1}{\hidepaste}
\tab{5}\spadcommand{g: (Integer,Float,Integer) -> String}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePageEmpty1}
\begin{paste}{ugUserDeclarePageEmpty1}{ugUserDeclarePagePatch1}
\pastebutton{ugUserDeclarePageEmpty1}{\showpaste}
\tab{5}\spadcommand{g: (Integer,Float,Integer) -> String}
\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePagePatch2}
\begin{paste}{ugUserDeclarePageFull2}{ugUserDeclarePageEmpty2}
\pastebutton{ugUserDeclarePageFull2}{\hidepaste}
\tab{5}\spadcommand{g: (INT,FLOAT,INT) -> STRING}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePageEmpty2}
\begin{paste}{ugUserDeclarePageEmpty2}{ugUserDeclarePagePatch2}
\pastebutton{ugUserDeclarePageEmpty2}{\showpaste}
\tab{5}\spadcommand{g: (INT,FLOAT,INT) -> STRING}
\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePagePatch3}
\begin{paste}{ugUserDeclarePageFull3}{ugUserDeclarePageEmpty3}
\pastebutton{ugUserDeclarePageFull3}{\hidepaste}
\tab{5}\spadcommand{h: () -> POLY INT}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePageEmpty3}
\begin{paste}{ugUserDeclarePageEmpty3}{ugUserDeclarePagePatch3}
\pastebutton{ugUserDeclarePageEmpty3}{\showpaste}
\tab{5}\spadcommand{h: () -> POLY INT}
\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePagePatch4}
\begin{paste}{ugUserDeclarePageFull4}{ugUserDeclarePageEmpty4}
\pastebutton{ugUserDeclarePageFull4}{\hidepaste}
\tab{5}\spadcommand{h: () -> Polynomial INT}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePageEmpty4}
\begin{paste}{ugUserDeclarePageEmpty4}{ugUserDeclarePagePatch4}
\pastebutton{ugUserDeclarePageEmpty4}{\showpaste}
\tab{5}\spadcommand{h: () -> Polynomial INT}
\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePagePatch5}
\begin{paste}{ugUserDeclarePageFull5}{ugUserDeclarePageEmpty5}
\pastebutton{ugUserDeclarePageFull5}{\hidepaste}
\tab{5}\spadcommand{h: () -> POLY Integer}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDeclarePageEmpty5}
\begin{paste}{ugUserDeclarePageEmpty5}{ugUserDeclarePagePatch5}
\pastebutton{ugUserDeclarePageEmpty5}{\showpaste}
\tab{5}\spadcommand{h: () -> POLY Integer}
\end{paste}\end{patch}

\begin{patch}{ugUserCompIntPagePatch1}
\begin{paste}{ugUserCompIntPageFull1}{ugUserCompIntPageEmpty1}
\pastebutton{ugUserCompIntPageFull1}{\hidepaste}
\tab{5}\spadcommand{varPolys(vars) ==
  for var in vars repeat
    output(1 :: UnivariatePolynomial(var,Integer))
\bound{varPolys }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCompIntPageEmpty1}
\begin{paste}{ugUserCompIntPageEmpty1}{ugUserCompIntPagePatch1}
\pastebutton{ugUserCompIntPageEmpty1}{\showpaste}
\tab{5}\spadcommand{varPolys(vars) ==
  for var in vars repeat
    output(1 :: UnivariatePolynomial(var,Integer))
\bound{varPolys }}
\end{paste}\end{patch}

\begin{patch}{ugUserCompIntPagePatch2}
\begin{paste}{ugUserCompIntPageFull2}{ugUserCompIntPageEmpty2}
\pastebutton{ugUserCompIntPageFull2}{\hidepaste}
\tab{5}\spadcommand{varPolys ['x,'y,'z]\free{varPolys }}
\indentrel{3}\begin{verbatim}
   1
   1
   1
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCompIntPageEmpty2}
\begin{paste}{ugUserCompIntPageEmpty2}{ugUserCompIntPagePatch2}
\pastebutton{ugUserCompIntPageEmpty2}{\showpaste}
\tab{5}\spadcommand{varPolys ['x,'y,'z]\free{varPolys }}
\end{paste}\end{patch}

\begin{patch}{ugUserCompIntPagePatch3}
\begin{paste}{ugUserCompIntPageFull3}{ugUserCompIntPageEmpty3}
\pastebutton{ugUserCompIntPageFull3}{\hidepaste}
\tab{5}\spadcommand{for var in ['x,'y,'z] repeat
  output(1 :: UnivariatePolynomial(var,Integer))
}
\indentrel{3}\begin{verbatim}
   1
   1
   1
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserCompIntPageEmpty3}
\begin{paste}{ugUserCompIntPageEmpty3}{ugUserCompIntPagePatch3}
\pastebutton{ugUserCompIntPageEmpty3}{\showpaste}
\tab{5}\spadcommand{for var in ['x,'y,'z] repeat
  output(1 :: UnivariatePolynomial(var,Integer))
}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch1}
\begin{paste}{ugUserDecUndecPageFull1}{ugUserDecUndecPageEmpty1}
\pastebutton{ugUserDecUndecPageFull1}{\hidepaste}
\tab{5}\spadcommand{f(x: Integer): Integer == x + 1\bound{f }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty1}
\begin{paste}{ugUserDecUndecPageEmpty1}{ugUserDecUndecPagePatch1}
\pastebutton{ugUserDecUndecPageEmpty1}{\showpaste}
\tab{5}\spadcommand{f(x: Integer): Integer == x + 1\bound{f }}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch2}
\begin{paste}{ugUserDecUndecPageFull2}{ugUserDecUndecPageEmpty2}
\pastebutton{ugUserDecUndecPageFull2}{\hidepaste}
\tab{5}\spadcommand{f 9\free{f }}
\indentrel{3}\begin{verbatim}
   (2)  10
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty2}
\begin{paste}{ugUserDecUndecPageEmpty2}{ugUserDecUndecPagePatch2}
\pastebutton{ugUserDecUndecPageEmpty2}{\showpaste}
\tab{5}\spadcommand{f 9\free{f }}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch3}
\begin{paste}{ugUserDecUndecPageFull3}{ugUserDecUndecPageEmpty3}
\pastebutton{ugUserDecUndecPageFull3}{\hidepaste}
\tab{5}\spadcommand{f(-2.0)\free{f }}
\indentrel{3}\begin{verbatim}
   (3)  - 1
                                          Type: Integer
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty3}
\begin{paste}{ugUserDecUndecPageEmpty3}{ugUserDecUndecPagePatch3}
\pastebutton{ugUserDecUndecPageEmpty3}{\showpaste}
\tab{5}\spadcommand{f(-2.0)\free{f }}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch4}
\begin{paste}{ugUserDecUndecPageFull4}{ugUserDecUndecPageEmpty4}
\pastebutton{ugUserDecUndecPageFull4}{\hidepaste}
\tab{5}\spadcommand{f(2/3)\free{f }}
\indentrel{3}\begin{verbatim}
error
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty4}
\begin{paste}{ugUserDecUndecPageEmpty4}{ugUserDecUndecPagePatch4}
\pastebutton{ugUserDecUndecPageEmpty4}{\showpaste}
\tab{5}\spadcommand{f(2/3)\free{f }}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch5}
\begin{paste}{ugUserDecUndecPageFull5}{ugUserDecUndecPageEmpty5}
\pastebutton{ugUserDecUndecPageFull5}{\hidepaste}
\tab{5}\spadcommand{g x == x + 1\bound{g }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty5}
\begin{paste}{ugUserDecUndecPageEmpty5}{ugUserDecUndecPagePatch5}
\pastebutton{ugUserDecUndecPageEmpty5}{\showpaste}
\tab{5}\spadcommand{g x == x + 1\bound{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch6}
\begin{paste}{ugUserDecUndecPageFull6}{ugUserDecUndecPageEmpty6}
\pastebutton{ugUserDecUndecPageFull6}{\hidepaste}
\tab{5}\spadcommand{g 9\free{g }}
\indentrel{3}\begin{verbatim}
   (5)  10
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty6}
\begin{paste}{ugUserDecUndecPageEmpty6}{ugUserDecUndecPagePatch6}
\pastebutton{ugUserDecUndecPageEmpty6}{\showpaste}
\tab{5}\spadcommand{g 9\free{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch7}
\begin{paste}{ugUserDecUndecPageFull7}{ugUserDecUndecPageEmpty7}
\pastebutton{ugUserDecUndecPageFull7}{\hidepaste}
\tab{5}\spadcommand{g(2/3)\free{g }}
\indentrel{3}\begin{verbatim}
        5
   (6)  -
        3
                                Type: Fraction(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty7}
\begin{paste}{ugUserDecUndecPageEmpty7}{ugUserDecUndecPagePatch7}
\pastebutton{ugUserDecUndecPageEmpty7}{\showpaste}
\tab{5}\spadcommand{g(2/3)\free{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPagePatch8}
\begin{paste}{ugUserDecUndecPageFull8}{ugUserDecUndecPageEmpty8}
\pastebutton{ugUserDecUndecPageFull8}{\hidepaste}
\tab{5}\spadcommand{g("fricas")\free{g }}
\indentrel{3}\begin{verbatim}
error
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDecUndecPageEmpty8}
\begin{paste}{ugUserDecUndecPageEmpty8}{ugUserDecUndecPagePatch8}
\pastebutton{ugUserDecUndecPageEmpty8}{\showpaste}
\tab{5}\spadcommand{g("fricas")\free{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch1}
\begin{paste}{ugUserDatabasePageFull1}{ugUserDatabasePageEmpty1}
\pastebutton{ugUserDatabasePageFull1}{\hidepaste}
\tab{5}\spadcommand{children("albert") == ["albertJr","richard","diane"]\bound{d1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty1}
\begin{paste}{ugUserDatabasePageEmpty1}{ugUserDatabasePagePatch1}
\pastebutton{ugUserDatabasePageEmpty1}{\showpaste}
\tab{5}\spadcommand{children("albert") == ["albertJr","richard","diane"]\bound{d1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch2}
\begin{paste}{ugUserDatabasePageFull2}{ugUserDatabasePageEmpty2}
\pastebutton{ugUserDatabasePageFull2}{\hidepaste}
\tab{5}\spadcommand{children("richard") == ["douglas","daniel","susan"]\free{d1 }\bound{d2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty2}
\begin{paste}{ugUserDatabasePageEmpty2}{ugUserDatabasePagePatch2}
\pastebutton{ugUserDatabasePageEmpty2}{\showpaste}
\tab{5}\spadcommand{children("richard") == ["douglas","daniel","susan"]\free{d1 }\bound{d2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch3}
\begin{paste}{ugUserDatabasePageFull3}{ugUserDatabasePageEmpty3}
\pastebutton{ugUserDatabasePageFull3}{\hidepaste}
\tab{5}\spadcommand{children("douglas") == ["dougie","valerie"]\free{d2 }\bound{d3 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty3}
\begin{paste}{ugUserDatabasePageEmpty3}{ugUserDatabasePagePatch3}
\pastebutton{ugUserDatabasePageEmpty3}{\showpaste}
\tab{5}\spadcommand{children("douglas") == ["dougie","valerie"]\free{d2 }\bound{d3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch4}
\begin{paste}{ugUserDatabasePageFull4}{ugUserDatabasePageEmpty4}
\pastebutton{ugUserDatabasePageFull4}{\hidepaste}
\tab{5}\spadcommand{children(x) == []\free{d3 }\bound{d4 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty4}
\begin{paste}{ugUserDatabasePageEmpty4}{ugUserDatabasePagePatch4}
\pastebutton{ugUserDatabasePageEmpty4}{\showpaste}
\tab{5}\spadcommand{children(x) == []\free{d3 }\bound{d4 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch5}
\begin{paste}{ugUserDatabasePageFull5}{ugUserDatabasePageEmpty5}
\pastebutton{ugUserDatabasePageFull5}{\hidepaste}
\tab{5}\spadcommand{childOf(x,y) == member?(x,children(y))\bound{d9 }\free{d10 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty5}
\begin{paste}{ugUserDatabasePageEmpty5}{ugUserDatabasePagePatch5}
\pastebutton{ugUserDatabasePageEmpty5}{\showpaste}
\tab{5}\spadcommand{childOf(x,y) == member?(x,children(y))\bound{d9 }\free{d10 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch6}
\begin{paste}{ugUserDatabasePageFull6}{ugUserDatabasePageEmpty6}
\pastebutton{ugUserDatabasePageFull6}{\hidepaste}
\tab{5}\spadcommand{parentOf(x) ==
  for y in people repeat
    (if childOf(x,y) then return y)
  "unknown"
\bound{d8a }\free{d9 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty6}
\begin{paste}{ugUserDatabasePageEmpty6}{ugUserDatabasePagePatch6}
\pastebutton{ugUserDatabasePageEmpty6}{\showpaste}
\tab{5}\spadcommand{parentOf(x) ==
  for y in people repeat
    (if childOf(x,y) then return y)
  "unknown"
\bound{d8a }\free{d9 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch7}
\begin{paste}{ugUserDatabasePageFull7}{ugUserDatabasePageEmpty7}
\pastebutton{ugUserDatabasePageFull7}{\hidepaste}
\tab{5}\spadcommand{grandParentOf(x) == parentOf parentOf x\bound{d8 }\free{d8a }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty7}
\begin{paste}{ugUserDatabasePageEmpty7}{ugUserDatabasePagePatch7}
\pastebutton{ugUserDatabasePageEmpty7}{\showpaste}
\tab{5}\spadcommand{grandParentOf(x) == parentOf parentOf x\bound{d8 }\free{d8a }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch8}
\begin{paste}{ugUserDatabasePageFull8}{ugUserDatabasePageEmpty8}
\pastebutton{ugUserDatabasePageFull8}{\hidepaste}
\tab{5}\spadcommand{grandchildren(x) == [y for y in people | grandParentOf(y) = x]\free{d7 }\bound{d8 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty8}
\begin{paste}{ugUserDatabasePageEmpty8}{ugUserDatabasePagePatch8}
\pastebutton{ugUserDatabasePageEmpty8}{\showpaste}
\tab{5}\spadcommand{grandchildren(x) == [y for y in people | grandParentOf(y) = x]\free{d7 }\bound{d8 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch9}
\begin{paste}{ugUserDatabasePageFull9}{ugUserDatabasePageEmpty9}
\pastebutton{ugUserDatabasePageFull9}{\hidepaste}
\tab{5}\spadcommand{greatGrandParents == [x for x in people |
  reduce(_or,[not empty? children(y) for y in grandchildren(x)],false)]
\free{d6 }\bound{d7 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty9}
\begin{paste}{ugUserDatabasePageEmpty9}{ugUserDatabasePagePatch9}
\pastebutton{ugUserDatabasePageEmpty9}{\showpaste}
\tab{5}\spadcommand{greatGrandParents == [x for x in people |
  reduce(_or,[not empty? children(y) for y in grandchildren(x)],false)]
\free{d6 }\bound{d7 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch10}
\begin{paste}{ugUserDatabasePageFull10}{ugUserDatabasePageEmpty10}
\pastebutton{ugUserDatabasePageFull10}{\hidepaste}
\tab{5}\spadcommand{descendants(x) ==
  kids := children(x)
  empty?(kids) => [x]
  concat(x,reduce(concat,[descendants(y)
    for y in kids],[]))
\free{d5 }\bound{d6 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty10}
\begin{paste}{ugUserDatabasePageEmpty10}{ugUserDatabasePagePatch10}
\pastebutton{ugUserDatabasePageEmpty10}{\showpaste}
\tab{5}\spadcommand{descendants(x) ==
  kids := children(x)
  empty?(kids) => [x]
  concat(x,reduce(concat,[descendants(y)
    for y in kids],[]))
\free{d5 }\bound{d6 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch11}
\begin{paste}{ugUserDatabasePageFull11}{ugUserDatabasePageEmpty11}
\pastebutton{ugUserDatabasePageFull11}{\hidepaste}
\tab{5}\spadcommand{people == descendants "albert"\free{d4 }\bound{d5 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty11}
\begin{paste}{ugUserDatabasePageEmpty11}{ugUserDatabasePagePatch11}
\pastebutton{ugUserDatabasePageEmpty11}{\showpaste}
\tab{5}\spadcommand{people == descendants "albert"\free{d4 }\bound{d5 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch12}
\begin{paste}{ugUserDatabasePageFull12}{ugUserDatabasePageEmpty12}
\pastebutton{ugUserDatabasePageFull12}{\hidepaste}
\tab{5}\spadcommand{grandchildren "richard"\bound{d10 }\free{d11 }}
\indentrel{3}\begin{verbatim}
   (12)  ["dougie", "valerie"]
                                     Type: List(String)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty12}
\begin{paste}{ugUserDatabasePageEmpty12}{ugUserDatabasePagePatch12}
\pastebutton{ugUserDatabasePageEmpty12}{\showpaste}
\tab{5}\spadcommand{grandchildren "richard"\bound{d10 }\free{d11 }}
\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePagePatch13}
\begin{paste}{ugUserDatabasePageFull13}{ugUserDatabasePageEmpty13}
\pastebutton{ugUserDatabasePageFull13}{\hidepaste}
\tab{5}\spadcommand{greatGrandParents\bound{d11 }\free{d12 }}
\indentrel{3}\begin{verbatim}
   (13)  ["albert"]
                                     Type: List(String)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserDatabasePageEmpty13}
\begin{paste}{ugUserDatabasePageEmpty13}{ugUserDatabasePagePatch13}
\pastebutton{ugUserDatabasePageEmpty13}{\showpaste}
\tab{5}\spadcommand{greatGrandParents\bound{d11 }\free{d12 }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch1}
\begin{paste}{ugUserTrianglePageFull1}{ugUserTrianglePageEmpty1}
\pastebutton{ugUserTrianglePageFull1}{\hidepaste}
\tab{5}\spadcommand{)set expose add constructor OutputForm\bound{expose }}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty1}
\begin{paste}{ugUserTrianglePageEmpty1}{ugUserTrianglePagePatch1}
\pastebutton{ugUserTrianglePageEmpty1}{\showpaste}
\tab{5}\spadcommand{)set expose add constructor OutputForm\bound{expose }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch2}
\begin{paste}{ugUserTrianglePageFull2}{ugUserTrianglePageEmpty2}
\pastebutton{ugUserTrianglePageFull2}{\hidepaste}
\tab{5}\spadcommand{pascal(1,i) == 1\bound{pas1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty2}
\begin{paste}{ugUserTrianglePageEmpty2}{ugUserTrianglePagePatch2}
\pastebutton{ugUserTrianglePageEmpty2}{\showpaste}
\tab{5}\spadcommand{pascal(1,i) == 1\bound{pas1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch3}
\begin{paste}{ugUserTrianglePageFull3}{ugUserTrianglePageEmpty3}
\pastebutton{ugUserTrianglePageFull3}{\hidepaste}
\tab{5}\spadcommand{pascal(n,n) == 1\bound{pas2 }\free{pas1 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty3}
\begin{paste}{ugUserTrianglePageEmpty3}{ugUserTrianglePagePatch3}
\pastebutton{ugUserTrianglePageEmpty3}{\showpaste}
\tab{5}\spadcommand{pascal(n,n) == 1\bound{pas2 }\free{pas1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch4}
\begin{paste}{ugUserTrianglePageFull4}{ugUserTrianglePageEmpty4}
\pastebutton{ugUserTrianglePageFull4}{\hidepaste}
\tab{5}\spadcommand{pascal(i,j | 1 < i and i < j) ==
   pascal(i-1,j-1)+pascal(i,j-1)
\bound{pas3 }\free{pas1 pas2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty4}
\begin{paste}{ugUserTrianglePageEmpty4}{ugUserTrianglePagePatch4}
\pastebutton{ugUserTrianglePageEmpty4}{\showpaste}
\tab{5}\spadcommand{pascal(i,j | 1 < i and i < j) ==
   pascal(i-1,j-1)+pascal(i,j-1)
\bound{pas3 }\free{pas1 pas2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch5}
\begin{paste}{ugUserTrianglePageFull5}{ugUserTrianglePageEmpty5}
\pastebutton{ugUserTrianglePageFull5}{\hidepaste}
\tab{5}\spadcommand{pascalRow(n) == [pascal(i,n) for i in 1..n]\bound{pascalRow }\free{pas3 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty5}
\begin{paste}{ugUserTrianglePageEmpty5}{ugUserTrianglePagePatch5}
\pastebutton{ugUserTrianglePageEmpty5}{\showpaste}
\tab{5}\spadcommand{pascalRow(n) == [pascal(i,n) for i in 1..n]\bound{pascalRow }\free{pas3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch6}
\begin{paste}{ugUserTrianglePageFull6}{ugUserTrianglePageEmpty6}
\pastebutton{ugUserTrianglePageFull6}{\hidepaste}
\tab{5}\spadcommand{displayRow(n) == output center blankSeparate pascalRow(n)\free{pascalRow }\bound{displayRow }\free{expose }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty6}
\begin{paste}{ugUserTrianglePageEmpty6}{ugUserTrianglePagePatch6}
\pastebutton{ugUserTrianglePageEmpty6}{\showpaste}
\tab{5}\spadcommand{displayRow(n) == output center blankSeparate pascalRow(n)\free{pascalRow }\bound{displayRow }\free{expose }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch7}
\begin{paste}{ugUserTrianglePageFull7}{ugUserTrianglePageEmpty7}
\pastebutton{ugUserTrianglePageFull7}{\hidepaste}
\tab{5}\spadcommand{for i in 1..7 repeat displayRow i\free{displayRow }}
\indentrel{3}\begin{verbatim}
                              1
                             1 1
                            1 2 1
                           1 3 3 1
                          1 4 6 4 1
                        1 5 10 10 5 1
                      1 6 15 20 15 6 1
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty7}
\begin{paste}{ugUserTrianglePageEmpty7}{ugUserTrianglePagePatch7}
\pastebutton{ugUserTrianglePageEmpty7}{\showpaste}
\tab{5}\spadcommand{for i in 1..7 repeat displayRow i\free{displayRow }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch8}
\begin{paste}{ugUserTrianglePageFull8}{ugUserTrianglePageEmpty8}
\pastebutton{ugUserTrianglePageFull8}{\hidepaste}
\tab{5}\spadcommand{pascalRow(n) == [right(pascal(i,n),4) for i in 1..n]\bound{pascalRow2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty8}
\begin{paste}{ugUserTrianglePageEmpty8}{ugUserTrianglePagePatch8}
\pastebutton{ugUserTrianglePageEmpty8}{\showpaste}
\tab{5}\spadcommand{pascalRow(n) == [right(pascal(i,n),4) for i in 1..n]\bound{pascalRow2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch9}
\begin{paste}{ugUserTrianglePageFull9}{ugUserTrianglePageEmpty9}
\pastebutton{ugUserTrianglePageFull9}{\hidepaste}
\tab{5}\spadcommand{for i in 1..7 repeat displayRow i\free{pascalRow2 }\free{displayRow }}
\indentrel{3}\begin{verbatim}
                               1
                             1    1
                          1    2    1
                        1    3    3    1
                     1    4    6    4    1
                   1    5   10   10    5    1
                1    6   15   20   15    6    1
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty9}
\begin{paste}{ugUserTrianglePageEmpty9}{ugUserTrianglePagePatch9}
\pastebutton{ugUserTrianglePageEmpty9}{\showpaste}
\tab{5}\spadcommand{for i in 1..7 repeat displayRow i\free{pascalRow2 }\free{displayRow }}
\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePagePatch10}
\begin{paste}{ugUserTrianglePageFull10}{ugUserTrianglePageEmpty10}
\pastebutton{ugUserTrianglePageFull10}{\hidepaste}
\tab{5}\spadcommand{)set expose drop constructor OutputForm}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserTrianglePageEmpty10}
\begin{paste}{ugUserTrianglePageEmpty10}{ugUserTrianglePagePatch10}
\pastebutton{ugUserTrianglePageEmpty10}{\showpaste}
\tab{5}\spadcommand{)set expose drop constructor OutputForm}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch1}
\begin{paste}{ugUserFreeLocalPageFull1}{ugUserFreeLocalPageEmpty1}
\pastebutton{ugUserFreeLocalPageFull1}{\hidepaste}
\tab{5}\spadcommand{counter := 0\bound{counter }}
\indentrel{3}\begin{verbatim}
   (1)  0
                               Type: NonNegativeInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty1}
\begin{paste}{ugUserFreeLocalPageEmpty1}{ugUserFreeLocalPagePatch1}
\pastebutton{ugUserFreeLocalPageEmpty1}{\showpaste}
\tab{5}\spadcommand{counter := 0\bound{counter }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch2}
\begin{paste}{ugUserFreeLocalPageFull2}{ugUserFreeLocalPageEmpty2}
\pastebutton{ugUserFreeLocalPageFull2}{\hidepaste}
\tab{5}\spadcommand{f() ==
  free counter
  counter := counter + 1
\free{counter }\bound{f }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty2}
\begin{paste}{ugUserFreeLocalPageEmpty2}{ugUserFreeLocalPagePatch2}
\pastebutton{ugUserFreeLocalPageEmpty2}{\showpaste}
\tab{5}\spadcommand{f() ==
  free counter
  counter := counter + 1
\free{counter }\bound{f }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch3}
\begin{paste}{ugUserFreeLocalPageFull3}{ugUserFreeLocalPageEmpty3}
\pastebutton{ugUserFreeLocalPageFull3}{\hidepaste}
\tab{5}\spadcommand{f()\free{f }\bound{f1 }}
\indentrel{3}\begin{verbatim}
   (3)  1
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty3}
\begin{paste}{ugUserFreeLocalPageEmpty3}{ugUserFreeLocalPagePatch3}
\pastebutton{ugUserFreeLocalPageEmpty3}{\showpaste}
\tab{5}\spadcommand{f()\free{f }\bound{f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch4}
\begin{paste}{ugUserFreeLocalPageFull4}{ugUserFreeLocalPageEmpty4}
\pastebutton{ugUserFreeLocalPageFull4}{\hidepaste}
\tab{5}\spadcommand{counter\free{f1 }}
\indentrel{3}\begin{verbatim}
   (4)  1
                               Type: NonNegativeInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty4}
\begin{paste}{ugUserFreeLocalPageEmpty4}{ugUserFreeLocalPagePatch4}
\pastebutton{ugUserFreeLocalPageEmpty4}{\showpaste}
\tab{5}\spadcommand{counter\free{f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch5}
\begin{paste}{ugUserFreeLocalPageFull5}{ugUserFreeLocalPageEmpty5}
\pastebutton{ugUserFreeLocalPageFull5}{\hidepaste}
\tab{5}\spadcommand{g() ==
  local counter
  counter := 7
\bound{g }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty5}
\begin{paste}{ugUserFreeLocalPageEmpty5}{ugUserFreeLocalPagePatch5}
\pastebutton{ugUserFreeLocalPageEmpty5}{\showpaste}
\tab{5}\spadcommand{g() ==
  local counter
  counter := 7
\bound{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch6}
\begin{paste}{ugUserFreeLocalPageFull6}{ugUserFreeLocalPageEmpty6}
\pastebutton{ugUserFreeLocalPageFull6}{\hidepaste}
\tab{5}\spadcommand{g()\free{g }}
\indentrel{3}\begin{verbatim}
   (6)  7
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty6}
\begin{paste}{ugUserFreeLocalPageEmpty6}{ugUserFreeLocalPagePatch6}
\pastebutton{ugUserFreeLocalPageEmpty6}{\showpaste}
\tab{5}\spadcommand{g()\free{g }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch7}
\begin{paste}{ugUserFreeLocalPageFull7}{ugUserFreeLocalPageEmpty7}
\pastebutton{ugUserFreeLocalPageFull7}{\hidepaste}
\tab{5}\spadcommand{counter\free{g f1 }}
\indentrel{3}\begin{verbatim}
   (7)  1
                               Type: NonNegativeInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty7}
\begin{paste}{ugUserFreeLocalPageEmpty7}{ugUserFreeLocalPagePatch7}
\pastebutton{ugUserFreeLocalPageEmpty7}{\showpaste}
\tab{5}\spadcommand{counter\free{g f1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch8}
\begin{paste}{ugUserFreeLocalPageFull8}{ugUserFreeLocalPageEmpty8}
\pastebutton{ugUserFreeLocalPageFull8}{\hidepaste}
\tab{5}\spadcommand{a := b := 1\bound{ab1 }}
\indentrel{3}\begin{verbatim}
   (8)  1
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty8}
\begin{paste}{ugUserFreeLocalPageEmpty8}{ugUserFreeLocalPagePatch8}
\pastebutton{ugUserFreeLocalPageEmpty8}{\showpaste}
\tab{5}\spadcommand{a := b := 1\bound{ab1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch9}
\begin{paste}{ugUserFreeLocalPageFull9}{ugUserFreeLocalPageEmpty9}
\pastebutton{ugUserFreeLocalPageFull9}{\hidepaste}
\tab{5}\spadcommand{h() ==
  b := a + 1
  a := b + a
\bound{hh }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty9}
\begin{paste}{ugUserFreeLocalPageEmpty9}{ugUserFreeLocalPagePatch9}
\pastebutton{ugUserFreeLocalPageEmpty9}{\showpaste}
\tab{5}\spadcommand{h() ==
  b := a + 1
  a := b + a
\bound{hh }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch10}
\begin{paste}{ugUserFreeLocalPageFull10}{ugUserFreeLocalPageEmpty10}
\pastebutton{ugUserFreeLocalPageFull10}{\hidepaste}
\tab{5}\spadcommand{h()\free{ab1 hh }\bound{hhh }}
\indentrel{3}\begin{verbatim}
   (10)  3
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty10}
\begin{paste}{ugUserFreeLocalPageEmpty10}{ugUserFreeLocalPagePatch10}
\pastebutton{ugUserFreeLocalPageEmpty10}{\showpaste}
\tab{5}\spadcommand{h()\free{ab1 hh }\bound{hhh }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch11}
\begin{paste}{ugUserFreeLocalPageFull11}{ugUserFreeLocalPageEmpty11}
\pastebutton{ugUserFreeLocalPageFull11}{\hidepaste}
\tab{5}\spadcommand{[a, b]\free{hhh }}
\indentrel{3}\begin{verbatim}
   (11)  [3, 1]
                            Type: List(PositiveInteger)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty11}
\begin{paste}{ugUserFreeLocalPageEmpty11}{ugUserFreeLocalPagePatch11}
\pastebutton{ugUserFreeLocalPageEmpty11}{\showpaste}
\tab{5}\spadcommand{[a, b]\free{hhh }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch12}
\begin{paste}{ugUserFreeLocalPageFull12}{ugUserFreeLocalPageEmpty12}
\pastebutton{ugUserFreeLocalPageFull12}{\hidepaste}
\tab{5}\spadcommand{)set fun cache all p\bound{pcache }}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty12}
\begin{paste}{ugUserFreeLocalPageEmpty12}{ugUserFreeLocalPagePatch12}
\pastebutton{ugUserFreeLocalPageEmpty12}{\showpaste}
\tab{5}\spadcommand{)set fun cache all p\bound{pcache }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch13}
\begin{paste}{ugUserFreeLocalPageFull13}{ugUserFreeLocalPageEmpty13}
\pastebutton{ugUserFreeLocalPageFull13}{\hidepaste}
\tab{5}\spadcommand{p(i,x) == ( free N; reduce( + , [ (x-i)^n for n in 1..N ] ) )\free{pcache }\bound{pdef }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty13}
\begin{paste}{ugUserFreeLocalPageEmpty13}{ugUserFreeLocalPagePatch13}
\pastebutton{ugUserFreeLocalPageEmpty13}{\showpaste}
\tab{5}\spadcommand{p(i,x) == ( free N; reduce( + , [ (x-i)^n for n in 1..N ] ) )\free{pcache }\bound{pdef }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch14}
\begin{paste}{ugUserFreeLocalPageFull14}{ugUserFreeLocalPageEmpty14}
\pastebutton{ugUserFreeLocalPageFull14}{\hidepaste}
\tab{5}\spadcommand{N := 1\bound{Nass }}
\indentrel{3}\begin{verbatim}
   (13)  1
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty14}
\begin{paste}{ugUserFreeLocalPageEmpty14}{ugUserFreeLocalPagePatch14}
\pastebutton{ugUserFreeLocalPageEmpty14}{\showpaste}
\tab{5}\spadcommand{N := 1\bound{Nass }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch15}
\begin{paste}{ugUserFreeLocalPageFull15}{ugUserFreeLocalPageEmpty15}
\pastebutton{ugUserFreeLocalPageFull15}{\hidepaste}
\tab{5}\spadcommand{p(0, x)\free{pdef Nass }\bound{pfirst }}
\indentrel{3}\begin{verbatim}
   (14)  x
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty15}
\begin{paste}{ugUserFreeLocalPageEmpty15}{ugUserFreeLocalPagePatch15}
\pastebutton{ugUserFreeLocalPageEmpty15}{\showpaste}
\tab{5}\spadcommand{p(0, x)\free{pdef Nass }\bound{pfirst }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch16}
\begin{paste}{ugUserFreeLocalPageFull16}{ugUserFreeLocalPageEmpty16}
\pastebutton{ugUserFreeLocalPageFull16}{\hidepaste}
\tab{5}\spadcommand{N := 2\bound{Nass2 }}
\indentrel{3}\begin{verbatim}
   (15)  2
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty16}
\begin{paste}{ugUserFreeLocalPageEmpty16}{ugUserFreeLocalPagePatch16}
\pastebutton{ugUserFreeLocalPageEmpty16}{\showpaste}
\tab{5}\spadcommand{N := 2\bound{Nass2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch17}
\begin{paste}{ugUserFreeLocalPageFull17}{ugUserFreeLocalPageEmpty17}
\pastebutton{ugUserFreeLocalPageFull17}{\hidepaste}
\tab{5}\spadcommand{p(0, x)\free{pfirst Nass2 }}
\indentrel{3}\begin{verbatim}
   (16)  x
                              Type: Polynomial(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty17}
\begin{paste}{ugUserFreeLocalPageEmpty17}{ugUserFreeLocalPagePatch17}
\pastebutton{ugUserFreeLocalPageEmpty17}{\showpaste}
\tab{5}\spadcommand{p(0, x)\free{pfirst Nass2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch18}
\begin{paste}{ugUserFreeLocalPageFull18}{ugUserFreeLocalPageEmpty18}
\pastebutton{ugUserFreeLocalPageFull18}{\hidepaste}
\tab{5}\spadcommand{)set fun cache 0 p}
\indentrel{3}\begin{verbatim}
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty18}
\begin{paste}{ugUserFreeLocalPageEmpty18}{ugUserFreeLocalPagePatch18}
\pastebutton{ugUserFreeLocalPageEmpty18}{\showpaste}
\tab{5}\spadcommand{)set fun cache 0 p}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch19}
\begin{paste}{ugUserFreeLocalPageFull19}{ugUserFreeLocalPageEmpty19}
\pastebutton{ugUserFreeLocalPageFull19}{\hidepaste}
\tab{5}\spadcommand{r : Record(i : Integer) := [1]\free{r }}
\indentrel{3}\begin{verbatim}
   (17)  [i = 1]
                               Type: Record(i: Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty19}
\begin{paste}{ugUserFreeLocalPageEmpty19}{ugUserFreeLocalPagePatch19}
\pastebutton{ugUserFreeLocalPageEmpty19}{\showpaste}
\tab{5}\spadcommand{r : Record(i : Integer) := [1]\free{r }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch20}
\begin{paste}{ugUserFreeLocalPageFull20}{ugUserFreeLocalPageEmpty20}
\pastebutton{ugUserFreeLocalPageFull20}{\hidepaste}
\tab{5}\spadcommand{resetRecord rr ==
  rr.i := 2
  rr := [10]
\bound{resetRecord }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty20}
\begin{paste}{ugUserFreeLocalPageEmpty20}{ugUserFreeLocalPagePatch20}
\pastebutton{ugUserFreeLocalPageEmpty20}{\showpaste}
\tab{5}\spadcommand{resetRecord rr ==
  rr.i := 2
  rr := [10]
\bound{resetRecord }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch21}
\begin{paste}{ugUserFreeLocalPageFull21}{ugUserFreeLocalPageEmpty21}
\pastebutton{ugUserFreeLocalPageFull21}{\hidepaste}
\tab{5}\spadcommand{resetRecord r\free{r resetRecord }\bound{rr }}
\indentrel{3}\begin{verbatim}
   (19)  [i = 10]
                               Type: Record(i: Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty21}
\begin{paste}{ugUserFreeLocalPageEmpty21}{ugUserFreeLocalPagePatch21}
\pastebutton{ugUserFreeLocalPageEmpty21}{\showpaste}
\tab{5}\spadcommand{resetRecord r\free{r resetRecord }\bound{rr }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch22}
\begin{paste}{ugUserFreeLocalPageFull22}{ugUserFreeLocalPageEmpty22}
\pastebutton{ugUserFreeLocalPageFull22}{\hidepaste}
\tab{5}\spadcommand{r\free{rr }}
\indentrel{3}\begin{verbatim}
   (20)  [i = 2]
                               Type: Record(i: Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty22}
\begin{paste}{ugUserFreeLocalPageEmpty22}{ugUserFreeLocalPagePatch22}
\pastebutton{ugUserFreeLocalPageEmpty22}{\showpaste}
\tab{5}\spadcommand{r\free{rr }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch23}
\begin{paste}{ugUserFreeLocalPageFull23}{ugUserFreeLocalPageEmpty23}
\pastebutton{ugUserFreeLocalPageFull23}{\hidepaste}
\tab{5}\spadcommand{past := present := 1\bound{f0 }}
\indentrel{3}\begin{verbatim}
   (21)  1
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty23}
\begin{paste}{ugUserFreeLocalPageEmpty23}{ugUserFreeLocalPagePatch23}
\pastebutton{ugUserFreeLocalPageEmpty23}{\showpaste}
\tab{5}\spadcommand{past := present := 1\bound{f0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch24}
\begin{paste}{ugUserFreeLocalPageFull24}{ugUserFreeLocalPageEmpty24}
\pastebutton{ugUserFreeLocalPageFull24}{\hidepaste}
\tab{5}\spadcommand{index := 2\bound{f1 }\free{f0 }}
\indentrel{3}\begin{verbatim}
   (22)  2
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty24}
\begin{paste}{ugUserFreeLocalPageEmpty24}{ugUserFreeLocalPagePatch24}
\pastebutton{ugUserFreeLocalPageEmpty24}{\showpaste}
\tab{5}\spadcommand{index := 2\bound{f1 }\free{f0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch25}
\begin{paste}{ugUserFreeLocalPageFull25}{ugUserFreeLocalPageEmpty25}
\pastebutton{ugUserFreeLocalPageFull25}{\hidepaste}
\tab{5}\spadcommand{fib(n) ==
  free past, present, index
  n < 3 => 1
  n = index - 1 => past
  if n < index-1 then
    (past,present) := (1,1)
    index := 2
  while (index < n) repeat
    (past,present) := (present, past+present)
    index := index + 1
  present
\bound{f3 }\free{f2 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty25}
\begin{paste}{ugUserFreeLocalPageEmpty25}{ugUserFreeLocalPagePatch25}
\pastebutton{ugUserFreeLocalPageEmpty25}{\showpaste}
\tab{5}\spadcommand{fib(n) ==
  free past, present, index
  n < 3 => 1
  n = index - 1 => past
  if n < index-1 then
    (past,present) := (1,1)
    index := 2
  while (index < n) repeat
    (past,present) := (present, past+present)
    index := index + 1
  present
\bound{f3 }\free{f2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch26}
\begin{paste}{ugUserFreeLocalPageFull26}{ugUserFreeLocalPageEmpty26}
\pastebutton{ugUserFreeLocalPageFull26}{\hidepaste}
\tab{5}\spadcommand{fibs := [fib(n) for n in 1..]\bound{fibs }\free{f3 }}
\indentrel{3}\begin{verbatim}
   (24)  [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...]
                          Type: Stream(PositiveInteger)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty26}
\begin{paste}{ugUserFreeLocalPageEmpty26}{ugUserFreeLocalPagePatch26}
\pastebutton{ugUserFreeLocalPageEmpty26}{\showpaste}
\tab{5}\spadcommand{fibs := [fib(n) for n in 1..]\bound{fibs }\free{f3 }}
\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPagePatch27}
\begin{paste}{ugUserFreeLocalPageFull27}{ugUserFreeLocalPageEmpty27}
\pastebutton{ugUserFreeLocalPageFull27}{\hidepaste}
\tab{5}\spadcommand{fibs 1000\free{fibs }}
\indentrel{3}\begin{verbatim}
   (25)
  434665576869374564356885276750406258025646605173717804_
   02481729089536555417949051890403879840079255169295922_
   59308032263477520968962323987332247116164299644090653_
   3187938298969649928516003704476137795166849228875
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserFreeLocalPageEmpty27}
\begin{paste}{ugUserFreeLocalPageEmpty27}{ugUserFreeLocalPagePatch27}
\pastebutton{ugUserFreeLocalPageEmpty27}{\showpaste}
\tab{5}\spadcommand{fibs 1000\free{fibs }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch1}
\begin{paste}{ugUserPiecePredPageFull1}{ugUserPiecePredPageEmpty1}
\pastebutton{ugUserPiecePredPageFull1}{\hidepaste}
\tab{5}\spadcommand{opposite 'right == 'left}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty1}
\begin{paste}{ugUserPiecePredPageEmpty1}{ugUserPiecePredPagePatch1}
\pastebutton{ugUserPiecePredPageEmpty1}{\showpaste}
\tab{5}\spadcommand{opposite 'right == 'left}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch2}
\begin{paste}{ugUserPiecePredPageFull2}{ugUserPiecePredPageEmpty2}
\pastebutton{ugUserPiecePredPageFull2}{\hidepaste}
\tab{5}\spadcommand{opposite (x | x = 'left) == 'right}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty2}
\begin{paste}{ugUserPiecePredPageEmpty2}{ugUserPiecePredPagePatch2}
\pastebutton{ugUserPiecePredPageEmpty2}{\showpaste}
\tab{5}\spadcommand{opposite (x | x = 'left) == 'right}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch3}
\begin{paste}{ugUserPiecePredPageFull3}{ugUserPiecePredPageEmpty3}
\pastebutton{ugUserPiecePredPageFull3}{\hidepaste}
\tab{5}\spadcommand{for x in ['right, 'left] repeat output opposite x}
\indentrel{3}\begin{verbatim}
   left
   right
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty3}
\begin{paste}{ugUserPiecePredPageEmpty3}{ugUserPiecePredPagePatch3}
\pastebutton{ugUserPiecePredPageEmpty3}{\showpaste}
\tab{5}\spadcommand{for x in ['right, 'left] repeat output opposite x}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch4}
\begin{paste}{ugUserPiecePredPageFull4}{ugUserPiecePredPageEmpty4}
\pastebutton{ugUserPiecePredPageFull4}{\hidepaste}
\tab{5}\spadcommand{opposite('inbetween)}
\indentrel{3}\begin{verbatim}
error
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty4}
\begin{paste}{ugUserPiecePredPageEmpty4}{ugUserPiecePredPagePatch4}
\pastebutton{ugUserPiecePredPageEmpty4}{\showpaste}
\tab{5}\spadcommand{opposite('inbetween)}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch5}
\begin{paste}{ugUserPiecePredPageFull5}{ugUserPiecePredPageEmpty5}
\pastebutton{ugUserPiecePredPageFull5}{\hidepaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x | x > 0,y | y < x) == true}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty5}
\begin{paste}{ugUserPiecePredPageEmpty5}{ugUserPiecePredPagePatch5}
\pastebutton{ugUserPiecePredPageEmpty5}{\showpaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x | x > 0,y | y < x) == true}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch6}
\begin{paste}{ugUserPiecePredPageFull6}{ugUserPiecePredPageEmpty6}
\pastebutton{ugUserPiecePredPageFull6}{\hidepaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x | x > 0 and y < x,y) == true}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty6}
\begin{paste}{ugUserPiecePredPageEmpty6}{ugUserPiecePredPagePatch6}
\pastebutton{ugUserPiecePredPageEmpty6}{\showpaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x | x > 0 and y < x,y) == true}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch7}
\begin{paste}{ugUserPiecePredPageFull7}{ugUserPiecePredPageEmpty7}
\pastebutton{ugUserPiecePredPageFull7}{\hidepaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x,y | x > 0 and y < x) == true\bound{ifq1a }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty7}
\begin{paste}{ugUserPiecePredPageEmpty7}{ugUserPiecePredPagePatch7}
\pastebutton{ugUserPiecePredPageEmpty7}{\showpaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x,y | x > 0 and y < x) == true\bound{ifq1a }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch8}
\begin{paste}{ugUserPiecePredPageFull8}{ugUserPiecePredPageEmpty8}
\pastebutton{ugUserPiecePredPageFull8}{\hidepaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x,y) == false\bound{ifq1b }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty8}
\begin{paste}{ugUserPiecePredPageEmpty8}{ugUserPiecePredPagePatch8}
\pastebutton{ugUserPiecePredPageEmpty8}{\showpaste}
\tab{5}\spadcommand{inFirstHalfQuadrant(x,y) == false\bound{ifq1b }}
\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPagePatch9}
\begin{paste}{ugUserPiecePredPageFull9}{ugUserPiecePredPageEmpty9}
\pastebutton{ugUserPiecePredPageFull9}{\hidepaste}
\tab{5}\spadcommand{[inFirstHalfQuadrant(i,3) for i in 1..5]\bound{ifq1b }}
\indentrel{3}\begin{verbatim}
   (8)  [false, false, false, true, true]
                                    Type: List(Boolean)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPiecePredPageEmpty9}
\begin{paste}{ugUserPiecePredPageEmpty9}{ugUserPiecePredPagePatch9}
\pastebutton{ugUserPiecePredPageEmpty9}{\showpaste}
\tab{5}\spadcommand{[inFirstHalfQuadrant(i,3) for i in 1..5]\bound{ifq1b }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch1}
\begin{paste}{ugUserAnonExampPageFull1}{ugUserAnonExampPageEmpty1}
\pastebutton{ugUserAnonExampPageFull1}{\hidepaste}
\tab{5}\spadcommand{x +-> if x < 0 then -x else x\bound{anon0 }}
\indentrel{3}\begin{verbatim}
   (1)
     x
   +-> 
     if x < 0
       then - x
       else x
                                Type: AnonymousFunction
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty1}
\begin{paste}{ugUserAnonExampPageEmpty1}{ugUserAnonExampPagePatch1}
\pastebutton{ugUserAnonExampPageEmpty1}{\showpaste}
\tab{5}\spadcommand{x +-> if x < 0 then -x else x\bound{anon0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch2}
\begin{paste}{ugUserAnonExampPageFull2}{ugUserAnonExampPageEmpty2}
\pastebutton{ugUserAnonExampPageFull2}{\hidepaste}
\tab{5}\spadcommand{abs1 := \%\free{anon0 }\bound{abs1 }}
\indentrel{3}\begin{verbatim}
   (2)
     x
   +-> 
     if x < 0
       then - x
       else x
                                Type: AnonymousFunction
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty2}
\begin{paste}{ugUserAnonExampPageEmpty2}{ugUserAnonExampPagePatch2}
\pastebutton{ugUserAnonExampPageEmpty2}{\showpaste}
\tab{5}\spadcommand{abs1 := \%\free{anon0 }\bound{abs1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch3}
\begin{paste}{ugUserAnonExampPageFull3}{ugUserAnonExampPageEmpty3}
\pastebutton{ugUserAnonExampPageFull3}{\hidepaste}
\tab{5}\spadcommand{(x,y) +-> abs1(x) > abs1(y)\bound{anon1 }\free{abs1 }}
\indentrel{3}\begin{verbatim}
   (3)  (x, y) +-> abs1(x) > abs1(y)
                                Type: AnonymousFunction
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty3}
\begin{paste}{ugUserAnonExampPageEmpty3}{ugUserAnonExampPagePatch3}
\pastebutton{ugUserAnonExampPageEmpty3}{\showpaste}
\tab{5}\spadcommand{(x,y) +-> abs1(x) > abs1(y)\bound{anon1 }\free{abs1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch4}
\begin{paste}{ugUserAnonExampPageFull4}{ugUserAnonExampPageEmpty4}
\pastebutton{ugUserAnonExampPageFull4}{\hidepaste}
\tab{5}\spadcommand{sort(\%,[3,9,-4,10,-3,-1,-9,5])\free{anon1 }}
\indentrel{3}\begin{verbatim}
   (4)  [10, - 9, 9, 5, - 4, - 3, 3, - 1]
                                    Type: List(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty4}
\begin{paste}{ugUserAnonExampPageEmpty4}{ugUserAnonExampPagePatch4}
\pastebutton{ugUserAnonExampPageEmpty4}{\showpaste}
\tab{5}\spadcommand{sort(\%,[3,9,-4,10,-3,-1,-9,5])\free{anon1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch5}
\begin{paste}{ugUserAnonExampPageFull5}{ugUserAnonExampPageEmpty5}
\pastebutton{ugUserAnonExampPageFull5}{\hidepaste}
\tab{5}\spadcommand{ev := ( (i,j) +-> if even?(i+j) then 1 else -1)\bound{ev }}
\indentrel{3}\begin{verbatim}
   (5)
     (i, j)
   +-> 
     if even?(i + j)
       then 1
       else - 1
                                Type: AnonymousFunction
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty5}
\begin{paste}{ugUserAnonExampPageEmpty5}{ugUserAnonExampPagePatch5}
\pastebutton{ugUserAnonExampPageEmpty5}{\showpaste}
\tab{5}\spadcommand{ev := ( (i,j) +-> if even?(i+j) then 1 else -1)\bound{ev }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch6}
\begin{paste}{ugUserAnonExampPageFull6}{ugUserAnonExampPageEmpty6}
\pastebutton{ugUserAnonExampPageFull6}{\hidepaste}
\tab{5}\spadcommand{matrix([[ev(row,col) for row in 1..4] for col in 1..4])\free{ev }}
\indentrel{3}\begin{verbatim}
        + 1   - 1   1   - 1+
        |                  |
        |- 1   1   - 1   1 |
   (6)  |                  |
        | 1   - 1   1   - 1|
        |                  |
        +- 1   1   - 1   1 +
                                  Type: Matrix(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty6}
\begin{paste}{ugUserAnonExampPageEmpty6}{ugUserAnonExampPagePatch6}
\pastebutton{ugUserAnonExampPageEmpty6}{\showpaste}
\tab{5}\spadcommand{matrix([[ev(row,col) for row in 1..4] for col in 1..4])\free{ev }}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch7}
\begin{paste}{ugUserAnonExampPageFull7}{ugUserAnonExampPageEmpty7}
\pastebutton{ugUserAnonExampPageFull7}{\hidepaste}
\tab{5}\spadcommand{( p +-> not one?(gcd(p,D(p,x))) )(x^2+4*x+4)}
\indentrel{3}\begin{verbatim}
   (7)  true
                                          Type: Boolean
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty7}
\begin{paste}{ugUserAnonExampPageEmpty7}{ugUserAnonExampPagePatch7}
\pastebutton{ugUserAnonExampPageEmpty7}{\showpaste}
\tab{5}\spadcommand{( p +-> not one?(gcd(p,D(p,x))) )(x^2+4*x+4)}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch8}
\begin{paste}{ugUserAnonExampPageFull8}{ugUserAnonExampPageEmpty8}
\pastebutton{ugUserAnonExampPageFull8}{\hidepaste}
\tab{5}\spadcommand{g(x,y,z) == cos(x + sin(y + tan(z)))}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty8}
\begin{paste}{ugUserAnonExampPageEmpty8}{ugUserAnonExampPagePatch8}
\pastebutton{ugUserAnonExampPageEmpty8}{\showpaste}
\tab{5}\spadcommand{g(x,y,z) == cos(x + sin(y + tan(z)))}
\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPagePatch9}
\begin{paste}{ugUserAnonExampPageFull9}{ugUserAnonExampPageEmpty9}
\pastebutton{ugUserAnonExampPageFull9}{\hidepaste}
\tab{5}\spadcommand{g == (x,y,z) +-> cos(x + sin(y + tan(z)))}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserAnonExampPageEmpty9}
\begin{paste}{ugUserAnonExampPageEmpty9}{ugUserAnonExampPagePatch9}
\pastebutton{ugUserAnonExampPageEmpty9}{\showpaste}
\tab{5}\spadcommand{g == (x,y,z) +-> cos(x + sin(y + tan(z)))}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch1}
\begin{paste}{ugUserPieceBasicPageFull1}{ugUserPieceBasicPageEmpty1}
\pastebutton{ugUserPieceBasicPageFull1}{\hidepaste}
\tab{5}\spadcommand{fact(0) == 1\bound{fact0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty1}
\begin{paste}{ugUserPieceBasicPageEmpty1}{ugUserPieceBasicPagePatch1}
\pastebutton{ugUserPieceBasicPageEmpty1}{\showpaste}
\tab{5}\spadcommand{fact(0) == 1\bound{fact0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch2}
\begin{paste}{ugUserPieceBasicPageFull2}{ugUserPieceBasicPageEmpty2}
\pastebutton{ugUserPieceBasicPageFull2}{\hidepaste}
\tab{5}\spadcommand{fact(n | n > 0) == n * fact(n - 1)\free{fact0 }\bound{factn }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty2}
\begin{paste}{ugUserPieceBasicPageEmpty2}{ugUserPieceBasicPagePatch2}
\pastebutton{ugUserPieceBasicPageEmpty2}{\showpaste}
\tab{5}\spadcommand{fact(n | n > 0) == n * fact(n - 1)\free{fact0 }\bound{factn }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch3}
\begin{paste}{ugUserPieceBasicPageFull3}{ugUserPieceBasicPageEmpty3}
\pastebutton{ugUserPieceBasicPageFull3}{\hidepaste}
\tab{5}\spadcommand{fact(3)\free{factn }}
\indentrel{3}\begin{verbatim}
   (3)  6
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty3}
\begin{paste}{ugUserPieceBasicPageEmpty3}{ugUserPieceBasicPagePatch3}
\pastebutton{ugUserPieceBasicPageEmpty3}{\showpaste}
\tab{5}\spadcommand{fact(3)\free{factn }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch4}
\begin{paste}{ugUserPieceBasicPageFull4}{ugUserPieceBasicPageEmpty4}
\pastebutton{ugUserPieceBasicPageFull4}{\hidepaste}
\tab{5}\spadcommand{fact(-3)\free{factn }}
\indentrel{3}\begin{verbatim}
error
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty4}
\begin{paste}{ugUserPieceBasicPageEmpty4}{ugUserPieceBasicPagePatch4}
\pastebutton{ugUserPieceBasicPageEmpty4}{\showpaste}
\tab{5}\spadcommand{fact(-3)\free{factn }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch5}
\begin{paste}{ugUserPieceBasicPageFull5}{ugUserPieceBasicPageEmpty5}
\pastebutton{ugUserPieceBasicPageFull5}{\hidepaste}
\tab{5}\spadcommand{facto(0) == 1\bound{facto0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty5}
\begin{paste}{ugUserPieceBasicPageEmpty5}{ugUserPieceBasicPagePatch5}
\pastebutton{ugUserPieceBasicPageEmpty5}{\showpaste}
\tab{5}\spadcommand{facto(0) == 1\bound{facto0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch6}
\begin{paste}{ugUserPieceBasicPageFull6}{ugUserPieceBasicPageEmpty6}
\pastebutton{ugUserPieceBasicPageFull6}{\hidepaste}
\tab{5}\spadcommand{facto(n | n < 0) == error "arguments to facto must be non-negative"\free{facto0 }\bound{factop }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty6}
\begin{paste}{ugUserPieceBasicPageEmpty6}{ugUserPieceBasicPagePatch6}
\pastebutton{ugUserPieceBasicPageEmpty6}{\showpaste}
\tab{5}\spadcommand{facto(n | n < 0) == error "arguments to facto must be non-negative"\free{facto0 }\bound{factop }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch7}
\begin{paste}{ugUserPieceBasicPageFull7}{ugUserPieceBasicPageEmpty7}
\pastebutton{ugUserPieceBasicPageFull7}{\hidepaste}
\tab{5}\spadcommand{facto(n) == n * facto(n - 1)\free{factop }\bound{facton }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty7}
\begin{paste}{ugUserPieceBasicPageEmpty7}{ugUserPieceBasicPagePatch7}
\pastebutton{ugUserPieceBasicPageEmpty7}{\showpaste}
\tab{5}\spadcommand{facto(n) == n * facto(n - 1)\free{factop }\bound{facton }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch8}
\begin{paste}{ugUserPieceBasicPageFull8}{ugUserPieceBasicPageEmpty8}
\pastebutton{ugUserPieceBasicPageFull8}{\hidepaste}
\tab{5}\spadcommand{facto(7)\free{facton }}
\indentrel{3}\begin{verbatim}
   (7)  5040
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty8}
\begin{paste}{ugUserPieceBasicPageEmpty8}{ugUserPieceBasicPagePatch8}
\pastebutton{ugUserPieceBasicPageEmpty8}{\showpaste}
\tab{5}\spadcommand{facto(7)\free{facton }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch9}
\begin{paste}{ugUserPieceBasicPageFull9}{ugUserPieceBasicPageEmpty9}
\pastebutton{ugUserPieceBasicPageFull9}{\hidepaste}
\tab{5}\spadcommand{facto(-7)\free{facton }}
\indentrel{3}\begin{verbatim}
error
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty9}
\begin{paste}{ugUserPieceBasicPageEmpty9}{ugUserPieceBasicPagePatch9}
\pastebutton{ugUserPieceBasicPageEmpty9}{\showpaste}
\tab{5}\spadcommand{facto(-7)\free{facton }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch10}
\begin{paste}{ugUserPieceBasicPageFull10}{ugUserPieceBasicPageEmpty10}
\pastebutton{ugUserPieceBasicPageFull10}{\hidepaste}
\tab{5}\spadcommand{)display value facto\free{facton }}
\indentrel{3}\begin{verbatim}
   CONCAT
      Definition:
  ,
      facto0 == 1
      facto(n | n < 0) ==
        error(arguments to facto must be non-negative)
      facto(n) == n facto(n - 1)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty10}
\begin{paste}{ugUserPieceBasicPageEmpty10}{ugUserPieceBasicPagePatch10}
\pastebutton{ugUserPieceBasicPageEmpty10}{\showpaste}
\tab{5}\spadcommand{)display value facto\free{facton }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch11}
\begin{paste}{ugUserPieceBasicPageFull11}{ugUserPieceBasicPageEmpty11}
\pastebutton{ugUserPieceBasicPageFull11}{\hidepaste}
\tab{5}\spadcommand{eleven(n | n < 1) == n + 11\bound{ff0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty11}
\begin{paste}{ugUserPieceBasicPageEmpty11}{ugUserPieceBasicPagePatch11}
\pastebutton{ugUserPieceBasicPageEmpty11}{\showpaste}
\tab{5}\spadcommand{eleven(n | n < 1) == n + 11\bound{ff0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch12}
\begin{paste}{ugUserPieceBasicPageFull12}{ugUserPieceBasicPageEmpty12}
\pastebutton{ugUserPieceBasicPageFull12}{\hidepaste}
\tab{5}\spadcommand{eleven(m) == eleven(eleven(m - 12))\bound{ff1 }\free{ff0 }}
\indentrel{3}\begin{verbatim}
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty12}
\begin{paste}{ugUserPieceBasicPageEmpty12}{ugUserPieceBasicPagePatch12}
\pastebutton{ugUserPieceBasicPageEmpty12}{\showpaste}
\tab{5}\spadcommand{eleven(m) == eleven(eleven(m - 12))\bound{ff1 }\free{ff0 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch13}
\begin{paste}{ugUserPieceBasicPageFull13}{ugUserPieceBasicPageEmpty13}
\pastebutton{ugUserPieceBasicPageFull13}{\hidepaste}
\tab{5}\spadcommand{elevens := [eleven(i) for i in 0..]\bound{ff2 }\free{ff1 }}
\indentrel{3}\begin{verbatim}
   (10)  [11, 11, 11, 11, 11, 11, 11, 11, 11, 11, ...]
                                  Type: Stream(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty13}
\begin{paste}{ugUserPieceBasicPageEmpty13}{ugUserPieceBasicPagePatch13}
\pastebutton{ugUserPieceBasicPageEmpty13}{\showpaste}
\tab{5}\spadcommand{elevens := [eleven(i) for i in 0..]\bound{ff2 }\free{ff1 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch14}
\begin{paste}{ugUserPieceBasicPageFull14}{ugUserPieceBasicPageEmpty14}
\pastebutton{ugUserPieceBasicPageFull14}{\hidepaste}
\tab{5}\spadcommand{elevens 200\free{ff2 }}
\indentrel{3}\begin{verbatim}
   (11)  11
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty14}
\begin{paste}{ugUserPieceBasicPageEmpty14}{ugUserPieceBasicPagePatch14}
\pastebutton{ugUserPieceBasicPageEmpty14}{\showpaste}
\tab{5}\spadcommand{elevens 200\free{ff2 }}
\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPagePatch15}
\begin{paste}{ugUserPieceBasicPageFull15}{ugUserPieceBasicPageEmpty15}
\pastebutton{ugUserPieceBasicPageFull15}{\hidepaste}
\tab{5}\spadcommand{)display value eleven\free{ff2 }}
\indentrel{3}\begin{verbatim}
   CONCAT
      Definition:
  ,
      eleven(m | m < 1) == m + 11
      eleven(m) == eleven(eleven(m - 12))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugUserPieceBasicPageEmpty15}
\begin{paste}{ugUserPieceBasicPageEmpty15}{ugUserPieceBasicPagePatch15}
\pastebutton{ugUserPieceBasicPageEmpty15}{\showpaste}
\tab{5}\spadcommand{)display value eleven\free{ff2 }}
\end{paste}\end{patch}

