Updated blockly examples; move static analysis to guide referenced in…

… concepts

tutorials/concepts/playground-overview.md

@@ -337,7 +337,7 @@ say that the contract passed all the tests, or to explain how it fails,
 and giving the sequence of transactions that lead to the error. As an
 exercise, try this with the `Escrow` contract, changing the initial
 deposit from Alice to something smaller than 450 lovelace. More details
-are given in the section on [static analysis](static-analysis.md) below. 
+are given in the section on [static analysis](/tutorials/guides/static-analysis).
 
 The **Analyse reachability** button will check whether any parts of a
 contract will never be executed, however participants interact with the

tutorials/concepts/potential-problems-with-contracts.md

@@ -28,14 +28,16 @@ can issue warnings from being ever written, but that would require
 Marlowe contracts to be dependently-typed, and writing expressions that
 are dependently-typed is much more cumbersome.
 
-Instead, Marlowe allows contracts that issue warning to be written, and
-we provide [static analysis tools](static-analysis.md) that let contract
-developers check whether a particular contract can possibly issue
-warnings. Additionally, we provide fall-back behaviours for when a
-contract produces a warning, despite our advice. We provide fall-back
-behaviours because we acknowledge that analysing big contracts can be
-very computationally expensive, and because mistakes can be made. We
-want badly written contracts to fail in the most harmless way possible,
+### Static analysis
+
+Marlowe allows contracts that issue warning to be written, and
+we provide [static analysis tools](/tutorials/guides/static-analysis) 
+that let contract developers check whether a particular contract can
+possibly issue warnings. Additionally, we provide fall-back behaviours
+for when a contract produces a warning, despite our advice. We provide
+fall-back behaviours because we acknowledge that analysing big contracts
+can be very computationally expensive, and because mistakes can be made.
+We want badly written contracts to fail in the most harmless way possible,
 that is conservatively.
 
 ### Non-positive payments

tutorials/concepts/static-analysis.md → tutorials/guides/static-analysis.md

@@ -1,9 +1,9 @@
 ---
-title: Static analysis
-sidebar_position: 9
+title: Static analysis using Blockly
+sidebar_position: 7
 ---
 
-# Static analysis
+# Static analysis using Blockly
 
 One distinctive feature of Marlowe -- probably its most distinctive
 feature -- is that we can analyze contracts, and deduce properties of
@@ -26,7 +26,7 @@ the account) to make a complete payment.
 
 ## An example
 
-Let us look at this example, in Blockly:
+Let us look at this example, in [Blockly](https://play.marlowe.iohk.io/#/blockly):
 
 ![An example contract in Blockly](/img/analysis1.png)
 
@@ -59,6 +59,45 @@ succeed:
 
 ![Successful analysis](/img/analysis4.png)
 
+The corrected contract is shown below:
+
+```
+When
+    [Case
+        (Deposit
+            (Role "alice")
+            (Role "alice")
+            (Token "" "")
+            (Constant 2)
+        )
+        (When
+            [Case
+                (Choice
+                    (ChoiceId
+                        "bool"
+                        (Role "bob")
+                    )
+                    [Bound 0 1]
+                )
+                (Pay
+                    (Role "alice")
+                    (Party (Role "bob"))
+                    (Token "" "")
+                    (AddValue
+                        (Constant 1)
+                        (ChoiceValue
+                            (ChoiceId
+                                "bool"
+                                (Role "bob")
+                            ))
+                    )
+                    Close 
+                )]
+            1677621600000 Close 
+        )]
+    1675202400000 Close 
+```
+
 ## Under the hood
 
 Just to re-iterate: the effect of this analysis is to check *every