`100 + let/cc k (10 + 1)`
+ This evaluates to `111`. Nothing exotic happens here. + +2.
`100 + let/cc k (10 + k 1)`
+ This evaluates to `101`; `(+ 100 (let/cc k (+ 10 (k 1))))` is the same as `(reset (+ 100 (shift k (k 1))))`. + +3.
```let p = let/cc k (1,k) in
+    let y = snd p (2, ident) in
+    (fst p, y)```
+ In the second line, we extract the continuation function (the bold part of the previous code) from the pair `p` and apply it to the argument `(2, ident)`. That results in the following code being run: +
```let p = (2, ident) in
+    let y = snd p (2, ident) in
+    (fst p, y)```
+ which in turn results in the nested pair `(2, (2, ident))`. + +4.
`1000 + (100 + abort 11)`
+ Here the box is implicit, understood to be the rest of the code. The result is just the abort value `11`, because the bold code is skipped. + +5.
`1000 + reset (100 + abort 11)`
+ Here the box or delimiter is explicitly specified. The bold code is skipped, but the outside code `1000 + < >` is still executed, so we get `1011`. + +6.
`1000 + reset (100 + shift k (10 + 1))`
+ Equivalent to preceding; results in `1011`. + +7.
`1000 + reset (100 + shift k (k (10 + 1)))`
+ Here we do invoke the captured continuation, so what gets passed to the outside code `1000 + < >` is `k (10 + 1)`, that is, `(100 + (10 + 1))`. Result is `1111`. + +8.
`1000 + reset (100 + shift k (10 + k 1))`
+ This also results in `1111`, but via a different path than the preceding. First, note that `k` is bound to `100 + < >`. So `k 1` is `101`. Then `10 + k 1` is `10 + 101`. Then we exit the body of `shift k ( ... )`, without invoking `k` again, so we don't anymore add `100`. Thus we pass `10 + 101` to the outside code `1000 + < >`. So the result is `1000 + (10 + 101)` or `1111`. (Whereas in the preceding example, the result was `1000 + (100 + 11)`. The order in which the operations are performed is different. If we used a non-commutative operation instead of `+`, the results of these two examples would be different from each other.) + +9.
`1000 + reset (100 + shift k (k)) 1`
+ Here `k` is bound to `100 + < >`. That's what's returned by the `shift k ( ... )` block, and since `k` isn't invoked (applied) when doing so, the rest of the bold `reset` block is skipped (for now). So we resume the outside code `1000 + < > 1`, with what fills the gap `< >` being the function that was bound to `k`. Thus this is equivalent to `1000 + (fun x -> 100 + x) 1` or `1000 + 101` or `1101`. + +10.
`1000 + reset (100 + shift k (k (k 1)))`