func (t *fixedTable) LongString(indent string, depth uint) string {
	var strs = make([]string, 3+t.nentries())
	strs[0] = indent + "fixedTable{"
	strs[1] = indent + fmt.Sprintf("\thashPath=%s, depth=%d, nents=%d,",
		t.hashPath.HashPathString(depth+1), t.depth, t.nents)
	var j = 0
	for i, n := range t.nodes {
		if t.nodes[i] != nil {
			if t, isTable := t.nodes[i].(tableI); isTable {
				strs[2+j] = indent + fmt.Sprintf("\tnodes[%d]:\n", i) +
					t.LongString(indent+"\t", depth+1)
			} else {
				strs[2+j] = indent + fmt.Sprintf("\tnodes[%d]: %s", i, n)
			}
			j++
		}
	}
	strs[len(strs)-1] = indent + "}"
	return strings.Join(strs, "\n")
}
LongString returns a string representation of this table and all the tables
contained herein recursively.
package hamt32
import (
	"fmt"
	"strings"
)
type fixedTable struct {
	nodes    [IndexLimit]nodeI
	depth    uint
	nents    uint
	hashPath HashVal
}
func (t *fixedTable) copy() tableI {
	var nt = new(fixedTable)
	*nt = *t
	return nt
}
func (t *fixedTable) deepCopy() tableI {
	var nt = new(fixedTable)
	nt.hashPath = t.hashPath
	nt.depth = t.depth
	nt.nents = t.nents
	for i := 0; i < len(t.nodes); i++ {
		if table, isTable := t.nodes[i].(tableI); isTable {
			nt.nodes[i] = table.deepCopy()
		} else {
			nt.nodes[i] = t.nodes[i]
		}
	}
	return nt
}
func createFixedTable(depth uint, leaf1 leafI, leaf2 *flatLeaf) tableI {
	if assertOn {
		assertf(depth > 0, "createFixedTable(): depth,%d < 1", depth)
		assertf(leaf1.Hash().hashPath(depth) == leaf2.Hash().hashPath(depth),
			"createFixedTable(): hp1,%s != hp2,%s",
			leaf1.Hash().hashPath(depth),
			leaf2.Hash().hashPath(depth))
	}
	var retTable = new(fixedTable)
	retTable.hashPath = leaf1.Hash().hashPath(depth)
	retTable.depth = depth
	var idx1 = leaf1.Hash().Index(depth)
	var idx2 = leaf2.Hash().Index(depth)
	if idx1 != idx2 {
		retTable.insert(idx1, leaf1)
		retTable.insert(idx2, leaf2)
	} else {  
		var node nodeI
		if depth == maxDepth {
			node = newCollisionLeaf(append(leaf1.keyVals(), leaf2.keyVals()...))
		} else {
			node = createFixedTable(depth+1, leaf1, leaf2)
		}
		retTable.insert(idx1, node)
	}
	return retTable
}
func upgradeToFixedTable(
	hashPath HashVal,
	depth uint,
	ents []tableEntry,
) *fixedTable {
	var ft = new(fixedTable)
	ft.hashPath = hashPath
	ft.depth = depth
	ft.nents = uint(len(ents))
	for _, ent := range ents {
		ft.nodes[ent.idx] = ent.node
	}
	return ft
}
func (t *fixedTable) Hash() HashVal {
	return t.hashPath
}
func (t *fixedTable) String() string {
	return fmt.Sprintf("fixedTable{hashPath=%s, depth=%d, nentries()=%d}",
		t.hashPath.HashPathString(t.depth), t.depth, t.nentries())
}