I am attempting to replicate some code in Expert F#, 'Using Continuations to Avoid Stack Overflow'. The tree I have built is balanced yet on the depth of 13, the stock overflows. All help appreciated.

type Tree =
| Node of string * Tree * Tree
| Leaf of string

let rec SizeNotTailRecursive tree =
match tree with
| Leaf _ -> 1
| Node (_, treeLeft, treeRight) ->
SizeNotTailRecursive treeLeft + SizeNotTailRecursive treeRight

let SizeUsingContinuation tree =
let rec Size tree cont =
match tree with
| Leaf _ -> cont 1
| Node (_, treeLeft, treeRight) ->
Size treeLeft (fun leftSize ->
Size treeRight (fun rightSize ->
cont (leftSize + rightSize)))

Size tree (fun x -> x)

let SizeUsingContinuationAcc tree =
let rec Size acc tree cont =
match tree with
| Leaf _ ->
cont (1 + acc)
| Node (_, treeLeft, treeRight) ->
Size acc treeLeft (fun accLeft ->
Size accLeft treeRight cont)

Size 0 tree (fun x -> x)

let rec MakeTree depth tree =
if depth = 0 then
tree
else
Node( "node" + depth.ToString(), MakeTree (depth - 1) tree, MakeTree (depth - 1) tree)

let treeDepth = 13
printfn "Building Tree of depth %A..." treeDepth
let tree = MakeTree treeDepth (Leaf "x")

printfn "Computing Tree size recursive..."
printfn "Size = %A" (SizeNotTailRecursive tree)

printfn "Computing Tree size continuation accumulator..."
printfn "Size = %A" (SizeUsingContinuationAcc tree)

printfn "Computing Tree size continuation..."
printfn "Size = %A" (SizeUsingContinuation tree)