if (!entryChildType.equals(TypeName.OBJECT)) {
                result.addStatement("$2T $1L = ($2T) $3L", paramVariable, entryChildType, argExpr);
            } else {
                result.addStatement("$2T $1L = $3L", paramVariable, entryChildType, argExpr);
            }
            paramVariablesStack.push(paramVariable);
        }
        visit(child, childArgCount);

        return result.stream().collect(CodeBlock.joining("\n\n"));
    }

    private static CodeBlock constructorScopeArg(TypeName constructedType) {
        return CodeBlock.of("$1T.constructorsOf($2T.class)", INTERCEPTED_SCOPE_CLASS, constructedType);
    }

    private static CodeBlock namedCallableScopesArgs(String name, List<CallInterceptionRequest> requests) {

000000a0  bb 17 03 03 00 42 02 e5  db dc 80 e1 c2 6f 31 1c  |.....B.......o1.|
000000b0  33 7b 76 8f 51 9c f8 a8  b0 1b 1a 8a 46 00 c7 ff  |3{v.Q.......F...|
000000c0  ff 4c c9 d8 28 14 32 74  ee 59 b3 15 4b 45 90 b6  |.L..(.2t.Y..KE..|
000000d0  da 56 b3 ef d4 6f 8a eb  96 b9 94 ab b9 9e b1 2e  |.V...o..........|
000000e0  fe 29 f2 0d 0d 93 66 1a  17 03 03 02 6d 84 4e 43  |.)....f.....m.NC|

multiplication, along with a few n-digit additions and subtractions. The standard
n-by-n-digit multiplication algorithm requires O(n²) time, making the overall
algorithm require time T(n) where

	T(n) = 2T(n/2) + O(n) + O(n²)

which, by the Bentley-Haken-Saxe theorem, ends up reducing to T(n) = O(n²).
This is not an improvement over regular long division.

		{"7.123456M", decQuantity(7123456, 0, DecimalSI)},
		{"6.987654321G", decQuantity(6987654321, 0, DecimalSI)},
		{"5.444T", decQuantity(5444, 9, DecimalSI)},
		{"40.1T", decQuantity(401, 11, DecimalSI)},
		{"300.2T", decQuantity(3002, 11, DecimalSI)},
		{"2.5P", decQuantity(25, 14, DecimalSI)},
		{"1.01E", decQuantity(101, 16, DecimalSI)},

		// Things that saturate/round
		{"3.001n", decQuantity(4, -9, DecimalSI)},