$%v$

$%v$

$%v$

#4D4D4D

$\text{Check}$

$\text{NEW PROBLEM}$

Fix position and allow selection for all text objects

Empty all input boxes

$a=\vphantom{b}$

$b=$

Reset app

\text{This is the error specific hint}

#006758

#B00020

#252525

#757575

#949494

#E44461

#DA2570

#E66B9E

#3A6ED6

#5991FF

#008475

#0F8538

#00a83c

#5145A8

#6557D2

#8575FF

#903D14

#BD6C43

#C75000

#E07415

\text{Use the bar model to help compare the fractions.}

#eeeeee

#2E006758

#2EB00020

\text{Drag to start}

\text{Compare the following fractions using < , > or =.} 

$%v$

$\text{Justify using common denominators}$

$\text{JUSTIFY USING COMMON DENOMINATOR}$

1 = arrow left, 2 = arrow right, 3 = arrow uo, 4 = arrow down

Reset

onboardingStage_{1} = 3
allRandomSeeds = RandomUniform(0, 0.99, 200)
hei_{1}: 0.8
y1_{1}: 1
chooseDen2_{1} = Sequence((10 / ii, y1_{1}), ii, 2, 20)
D_{1} = Point(chooseDen2_{1})
d2_{1}: 10 / x(D_{1})
chooseNum2_{1} = Sequence(((10 * ii / d2_{1}), y1_{1} + hei_{1}), ii, 0, d2_{1})
B_{1} = Point(chooseNum2_{1})
ComparisonBar2_{1} = Segment(B_{1}, B_{1} + (0, 1.1))
F_{1} = Vertex(ComparisonBar2_{1}, 2)
y2_{1}: y(F_{1})
y3_{1}: y2_{1} + y2_{1} - y1_{1} - hei_{1}
C1_{1}: (0, y3_{1})
chooseDen1_{1} = Sequence((10 / ii, y3_{1}), ii, 2, 20)
C_{1} = Point(chooseDen1_{1})
d1_{1}: 10 / x(C_{1})
C2_{1}: C1_{1} + (10 / d1_{1}, 0)
D1_{1} = Polygon({C1_{1}, C2_{1}, C2_{1} + (0, hei_{1}), C1_{1} + (0, hei_{1})})
C3_{1}: C2_{1} + (10 / d1_{1}, 0)
D2_{1} = Polygon({C2_{1}, C3_{1}, C3_{1} + (0, hei_{1}), C2_{1} + (0, hei_{1})})
C4_{1}: C3_{1} + (10 / d1_{1}, 0)
D3_{1} = Polygon({C3_{1}, C4_{1}, C4_{1} + (0, hei_{1}), C3_{1} + (0, hei_{1})})
C5_{1}: C4_{1} + (10 / d1_{1}, 0)
D4_{1} = Polygon({C4_{1}, C5_{1}, C5_{1} + (0, hei_{1}), C4_{1} + (0, hei_{1})})
C6_{1}: C5_{1} + (10 / d1_{1}, 0)
D5_{1} = Polygon({C5_{1}, C6_{1}, C6_{1} + (0, hei_{1}), C5_{1} + (0, hei_{1})})
C7_{1}: C6_{1} + (10 / d1_{1}, 0)
D6_{1} = Polygon({C6_{1}, C7_{1}, C7_{1} + (0, hei_{1}), C6_{1} + (0, hei_{1})})
C8_{1}: C7_{1} + (10 / d1_{1}, 0)
D7_{1} = Polygon({C7_{1}, C8_{1}, C8_{1} + (0, hei_{1}), C7_{1} + (0, hei_{1})})
C9_{1}: C8_{1} + (10 / d1_{1}, 0)
D8_{1} = Polygon({C8_{1}, C9_{1}, C9_{1} + (0, hei_{1}), C8_{1} + (0, hei_{1})})
C10_{1}: C9_{1} + (10 / d1_{1}, 0)
D9_{1} = Polygon({C9_{1}, C10_{1}, C10_{1} + (0, hei_{1}), C9_{1} + (0, hei_{1})})
C11_{1}: C10_{1} + (10 / d1_{1}, 0)
D10_{1} = Polygon({C10_{1}, C11_{1}, C11_{1} + (0, hei_{1}), C10_{1} + (0, hei_{1})})
C12_{1}: C11_{1} + (10 / d1_{1}, 0)
D11_{1} = Polygon({C11_{1}, C12_{1}, C12_{1} + (0, hei_{1}), C11_{1} + (0, hei_{1})})
C13_{1}: C12_{1} + (10 / d1_{1}, 0)
D12_{1} = Polygon({C12_{1}, C13_{1}, C13_{1} + (0, hei_{1}), C12_{1} + (0, hei_{1})})
C14_{1}: C13_{1} + (10 / d1_{1}, 0)
D13_{1} = Polygon({C13_{1}, C14_{1}, C14_{1} + (0, hei_{1}), C13_{1} + (0, hei_{1})})
C15_{1}: C14_{1} + (10 / d1_{1}, 0)
D14_{1} = Polygon({C14_{1}, C15_{1}, C15_{1} + (0, hei_{1}), C14_{1} + (0, hei_{1})})
C16_{1}: C15_{1} + (10 / d1_{1}, 0)
D15_{1} = Polygon({C15_{1}, C16_{1}, C16_{1} + (0, hei_{1}), C15_{1} + (0, hei_{1})})
C17_{1}: C16_{1} + (10 / d1_{1}, 0)
D16_{1} = Polygon({C16_{1}, C17_{1}, C17_{1} + (0, hei_{1}), C16_{1} + (0, hei_{1})})
C18_{1}: C17_{1} + (10 / d1_{1}, 0)
D17_{1} = Polygon({C17_{1}, C18_{1}, C18_{1} + (0, hei_{1}), C17_{1} + (0, hei_{1})})
C19_{1}: C18_{1} + (10 / d1_{1}, 0)
D18_{1} = Polygon({C18_{1}, C19_{1}, C19_{1} + (0, hei_{1}), C18_{1} + (0, hei_{1})})
C20_{1}: C19_{1} + (10 / d1_{1}, 0)
D19_{1} = Polygon({C19_{1}, C20_{1}, C20_{1} + (0, hei_{1}), C19_{1} + (0, hei_{1})})
C21_{1}: C20_{1} + (10 / d1_{1}, 0)
D20_{1} = Polygon({C20_{1}, C21_{1}, C21_{1} + (0, hei_{1}), C20_{1} + (0, hei_{1})})
chooseNum1_{1} = Sequence(((10 * ii / d1_{1}), y3_{1} + hei_{1}), ii, 0, d1_{1})
A_{1} = Point(chooseNum1_{1})
n1_{1}: (x(A_{1}) / 10 * d1_{1})
q2_{1} = Element(Take[{D1_{1}, D2_{1}, D3_{1}, D4_{1}, D5_{1}, D6_{1}, D7_{1}, D8_{1}, D9_{1}, D10_{1}, D11_{1}, D12_{1}, D13_{1}, D14_{1}, D15_{1}, D16_{1}, D17_{1}, D18_{1}, D19_{1}, D20_{1}}, 1, d1_{1}], If[n1_{1} ≟ d1_{1} - 1, d1_{1}, d1_{1} - 1])
Cor3 = (11.802515069775882, 8.179768328709228)
Cor1 = (-1.8025150697758814, -0.3360984169952581)
posOB1: ((x(C_{1}) - x(Cor1)) * 800 / x(Cor3 - Cor1)) - 12
posOB2_{1}: ((x(Vertex[q2_{1}, 1] + Vertex[q2_{1}, 2]) / 2 - x(Cor1)) * 800 / x(Cor3 - Cor1)) - 8
numRandoms: 5
countQuestion = 0
randIndex: (Mod[countQuestion, floor(Length[allRandomSeeds] / numRandoms)] * numRandoms) + 1
currentRandomSeeds = Take(allRandomSeeds, randIndex, randIndex + numRandoms - 1)
Den1: 2 + floor((currentRandomSeeds(2) * 19))
Num1: 1 + floor((currentRandomSeeds(2) * Den1))
text1: "\frac{" + (LaTeX[Num1]) + "}{" + (LaTeX[Den1]) + "}"
Den2: 2 + floor((currentRandomSeeds(3) * 19))
Num2: 1 + floor((currentRandomSeeds(2) * Den2))
text2: "\frac{" + (LaTeX[Num2]) + "}{" + (LaTeX[Den2]) + "}"
Menu: {"$ \phantom{<\;}$", "$<\;$ ", "$>\; $", "$=\; \vspace{12}$"}
frac2: Num2 / Den2
frac1: Num1 / Den1
expected = If(frac1 ≟ frac2, 4, If[frac1 ≤ frac2, 2, 3])
onboarding = false
inputSaved: {1}
input2 = NaN
input1 = NaN
inputCurrent: {SelectedIndex[Menu]}
correct1: input1 ≟ Den1
validate = false
showanswer = false
showsolution = false
tries = 0
countCorrect = 0
showhint = false
InputBox1 = Textfield(input1)
InputBox2 = Textfield(input2)
correct2: input2 ≟ Den2
correct: SelectedIndex[Menu] ≟ expected
isTypicalError: input2 ≟ input1 + 1
showbuttons = true
showhinttypicalerror = false
textCountCorrect: "\text{Number correct: " + (LaTeX[countCorrect]) + " }"
pixelsRight: 16
pixelsLeft: 16
pixelsBottom: 16
pixelsTop: 24
borderBox = Polygon(Zip[PixelsToPoint[Corner[1], Corner[3], Corner[5], A], A, {(pixelsLeft, pixelsTop), (pixelsLeft, y(Corner[5]) - pixelsBottom), Corner[5] - (pixelsRight, pixelsBottom), (x(Corner[5]) - pixelsRight, pixelsTop)}])
textHint: "\text{\color{" + (LaTeX[colorOrange]) + "}\bold{Hint}\\" + (LaTeX[If[showhinttypicalerror, helpTextHintTypicalError]]) + "" + (LaTeX[If[showhint ∧ showhinttypicalerror, "\\"]]) + "" + (LaTeX[If[showhint, helpTextHint]]) + "}"
layoutY: 65
layoutX: 174
layoutAppSize = Corner(5)
enableBtnValidate: inputCurrent ≠ inputSaved ∧ SelectedIndex[Menu] ≠ 1
pulsingSpeed: 8
pulsing = 0.6 (slider from 0 to 1, step 0.1)
onboardingCase: 1
onboardingX: 337
onboardingY: 150
OnboardingTextOffset = onboardingTextOffset(Corner[onboardingText, 1], Corner[onboardingText, 3], onboardingCase, Corner[1], Corner[3], Corner[5])
onboardingDisplayText: "" + (LaTeX[onboardingText]) + ""
textSolution: "\textsf{\bold{Solution}}\\" + (LaTeX[text1]) + "" + (LaTeX[Element[{"<", ">", "="}, expected - 1]]) + "" + (LaTeX[text2]) + ""
altFeedback: "\text{" + (LaTeX[If[correct, "Your answer is correct. ", ("Your answer is not correct. " * If[tries < 3, "Try again. ", "Maybe next time. "])]]) + "}"
solutionView: showanswer ∨ showsolution
enableInput: tries < 2 ∧ (¬(validate ∧ correct))
labelBtnValidate: "\text{CHECK (" + (LaTeX[2 - tries]) + ")}"
textFeedback: "\text{\vphantom{✕}" + (LaTeX[If[correct, (("\textcolor{" * colorTealSuccess) * "}{✓ Correct}"), (((("\textcolor{" * colorRedError) * "}{✕ ") * If[tries < 2, "Try again", "Maybe next time"]) * "}")]]) + ""
a = 3.921834955856985
Cor3_{1} = (11.015, 5.775119047619047)
Cor1_{1} = (-1.0150000000000001, -1.754880952380952)
mcm_{1} = LCM(d1_{1}, d2_{1})
anim_{1} = 1 (slider from 0 to 1)
ComparisonBar_{1} = Segment(A_{1}, A_{1} - (0, 2.5))
E_{1}: (x(A_{1}), y2_{1})
text5_{1} = Text(If[n1_{1} ≠ 0 ∧ d1_{1} ≠ n1_{1}, (((("\frac{" * n1_{1}) * "}{") * d1_{1}) * "}"), Text[n1_{1} / d1_{1}]], E_{1}, true, true, 0, 1)
textLeft_{1}: "" + (LaTeX[text5_{1} + (If[d1_{1} ≟ mcm_{1}, "", (((("=\frac{" * (n1_{1} * mcm_{1} / d1_{1})) * "}{") * mcm_{1}) * "}")])]) + ""
n2_{1}: (x(B_{1}) / 10 * d2_{1})
text6_{1} = Text(If[n2_{1} ≠ 0 ∧ n2_{1} ≠ d2_{1}, (((("\frac{" * n2_{1}) * "}{") * d2_{1}) * "}"), Text[n2_{1} / d2_{1}]], Midpoint[F_{1}, B_{1}], true, true, 0, 0)
textRight_{1}: "" + (LaTeX[If[d2_{1} ≟ mcm_{1}, "", (((("\frac{" * (n2_{1} * mcm_{1} / d2_{1})) * "}{") * mcm_{1}) * "}=")] + text6_{1}]) + ""
PointsNL2_{1} = Sequence(((10 / d2_{1} * ii), 1), ii, 0, d2_{1})
AppSize_{1} = Corner(5)
MoveGuideLine_{1} = (9.015012500000003, -0.17358095238095272)
hGuideline_{1}: y = y(MoveGuideLine_{1})
vGuideline_{1}: x = x(MoveGuideLine_{1})
vGuideline'_{1} = Translate(vGuideline_{1}, Vector[(Vector[Corner[1], Corner[2]] / 800 * 16)])
Nl2_{1} = Segment((-0.5, 0.97992), (10.5, 0.97992))
Bar1_{1} = Polygon({(0, y3_{1}), (10, y3_{1}), (10, y3_{1} + hei_{1}), (0, y3_{1} + hei_{1})})
Bar2_{1} = Polygon({(0, y1_{1}), (10, y1_{1}), (10, y1_{1} + hei_{1}), (0, y1_{1} + hei_{1})})
PointsBar1_{1} = Sequence(((10 / d1_{1} * ii), y3_{1} + hei_{1}), ii, 0, d1_{1})
PointsBar1'_{1} = Sequence(((10 / d1_{1} * ii), y3_{1}), ii, 0, d1_{1})
PointsBar2_{1} = Sequence(((10 / d2_{1} * ii), y1_{1} + hei_{1}), ii, 0, d2_{1})
PointsBar2'_{1} = Sequence(((10 / d2_{1} * ii), y1_{1}), ii, 0, d2_{1})
divisionsBar1_{1} = Zip(Segment[PP, QQ], PP, PointsBar1_{1}, QQ, PointsBar1'_{1})
divisionsBar2_{1} = Zip(Segment[PP, QQ], PP, PointsBar2'_{1}, QQ, PointsBar2_{1})
FractionModel1_{1} = Polygon({PointsBar1'_{1}(1), PointsBar1'_{1}(n1_{1} + 1), PointsBar1_{1}(n1_{1} + 1), PointsBar1_{1}(1)})
FractionModel2_{1} = Polygon({PointsBar2'_{1}(1), PointsBar2'_{1}(n2_{1} + 1), PointsBar2_{1}(n2_{1} + 1), PointsBar2_{1}(1)})
text2_{1} = Text("0", PointsNL2_{1}(1), true, true, 0, -1)
text3_{1} = Text("1", PointsNL2_{1}(-1), true, true, 0, -1)
speed_{1}: 3
PointsNL1_{1} = Sequence(((10 / mcm_{1} * ii), y2_{1}), ii, 0, mcm_{1})
ticksNL1_{1} = Zip(Segment[PP + (0, 0.1), PP - (0, 0.1)], PP, PointsNL1_{1})
ticksNL2_{1} = Zip(Segment[PP + (0, 0.1), PP - (0, 0.1)], PP, PointsNL2_{1})
compare_{1} = false
texto1_{1}: "\textcolor{#DA2570}{" + (LaTeX[textLeft_{1}]) + "}\textcolor{#252525}{" + (LaTeX[If[n1_{1} / d1_{1} ≟ n2_{1} / d2_{1}, "\;=\;", If[n1_{1} / d1_{1} ≥ n2_{1} / d2_{1}, "\; > \;", "\; < \;"]]]) + "}\textcolor{#3A6ED6}{" + (LaTeX[textRight_{1}]) + "}"
text7_{1} = TableText({texto1_{1}}, "c", 400, 0)
l1_{1} = Sequence(((10 / mcm_{1} * ii), y3_{1} + hei_{1}), ii, 0, mcm_{1})
l2_{1} = Sequence(((10 / mcm_{1} * ii), y3_{1}), ii, 0, mcm_{1})
l4_{1} = Sequence(((10 / mcm_{1} * ii), y1_{1}), ii, 0, mcm_{1})
l5_{1} = Zip(Segment[PP, QQ], PP, l1_{1}, QQ, l2_{1})
l3_{1} = Sequence(((10 / mcm_{1} * ii), y1_{1} + hei_{1}), ii, 0, mcm_{1})
l6_{1} = Zip(Segment[PP, QQ], PP, l3_{1}, QQ, l4_{1})
speed0_{1}: 0
onboarding_{1} = false
pulsingSpeed_{1}: 8
pulsing_{1} = 0.8 (slider from 0 to 1, step 0.1)
onboarding_{2}: onboarding_{1}
onboardingX_{1} = If(onboardingStage_{1} ≟ 1, posOB1, posOB2_{1})
onboardingY_{1} = 275.5
onboardingText_{1}: "\text{" + (LaTeX[If[onboardingStage_{1} ≟ 1, "Drag to change denominator", "Click to change numerator"]]) + "}"
onboardingCase_{1}: 3
OnboardingTextOffset_{1} = onboardingTextOffset(Corner[onboardingText_{1}, 1], Corner[onboardingText_{1}, 3], onboardingCase_{1}, Corner[1], Corner[3], Corner[5])
onboardingDisplayText_{1}: "\text{\vphantom{Og}" + (LaTeX[onboardingText_{1}]) + "}"
NL1_{1} = Segment((-0.5, y2_{1}), (10.5, y2_{1}))
f_{1} = Segment((0, y2_{1} + 0.2), (0, y2_{1} - 0.2))
g_{1} = Segment((10, y2_{1} - 0.2), (10, y2_{1} + 0.2))
text1_{1} = Text("0", (0, y2_{1} + 0.2), true, true, 0, 1)
text4_{1} = Text("1", (10, y2_{1} + 0.2), true, true, 0, 1)
pulsingC_{1} = circlePixels(C_{1}, 9 + (7 * pulsing_{1}), Corner[1], Corner[3], Corner[5])
pulsingD_{1} = circlePixels(D_{1}, 9 + (7 * pulsing_{1}), Corner[1], Corner[3], Corner[5])
hGuideline'_{1} = Translate(hGuideline_{1}, Vector[(Vector[Corner[1], Corner[4]] / 500 * 16)])
A1_{1}: (0, y1_{1})
A2_{1}: A1_{1} + (10 / d2_{1}, 0)
A3_{1}: A2_{1} + (10 / d2_{1}, 0)
A4_{1}: A3_{1} + (10 / d2_{1}, 0)
A5_{1}: A4_{1} + (10 / d2_{1}, 0)
A6_{1}: A5_{1} + (10 / d2_{1}, 0)
A7_{1}: A6_{1} + (10 / d2_{1}, 0)
A8_{1}: A7_{1} + (10 / d2_{1}, 0)
A9_{1}: A8_{1} + (10 / d2_{1}, 0)
A10_{1}: A9_{1} + (10 / d2_{1}, 0)
A11_{1}: A10_{1} + (10 / d2_{1}, 0)
A12_{1}: A11_{1} + (10 / d2_{1}, 0)
A13_{1}: A12_{1} + (10 / d2_{1}, 0)
A14_{1}: A13_{1} + (10 / d2_{1}, 0)
A15_{1}: A14_{1} + (10 / d2_{1}, 0)
A16_{1}: A15_{1} + (10 / d2_{1}, 0)
A17_{1}: A16_{1} + (10 / d2_{1}, 0)
A18_{1}: A17_{1} + (10 / d2_{1}, 0)
A19_{1}: A18_{1} + (10 / d2_{1}, 0)
A20_{1}: A19_{1} + (10 / d2_{1}, 0)
A21_{1}: A20_{1} + (10 / d2_{1}, 0)
B1_{1} = Polygon({A1_{1}, A2_{1}, A2_{1} + (0, hei_{1}), A1_{1} + (0, hei_{1})})
B2_{1} = Polygon({A2_{1}, A3_{1}, A3_{1} + (0, hei_{1}), A2_{1} + (0, hei_{1})})
B3_{1} = Polygon({A3_{1}, A4_{1}, A4_{1} + (0, hei_{1}), A3_{1} + (0, hei_{1})})
B4_{1} = Polygon({A4_{1}, A5_{1}, A5_{1} + (0, hei_{1}), A4_{1} + (0, hei_{1})})
B5_{1} = Polygon({A5_{1}, A6_{1}, A6_{1} + (0, hei_{1}), A5_{1} + (0, hei_{1})})
B6_{1} = Polygon({A6_{1}, A7_{1}, A7_{1} + (0, hei_{1}), A6_{1} + (0, hei_{1})})
B7_{1} = Polygon({A7_{1}, A8_{1}, A8_{1} + (0, hei_{1}), A7_{1} + (0, hei_{1})})
B8_{1} = Polygon({A8_{1}, A9_{1}, A9_{1} + (0, hei_{1}), A8_{1} + (0, hei_{1})})
B9_{1} = Polygon({A9_{1}, A10_{1}, A10_{1} + (0, hei_{1}), A9_{1} + (0, hei_{1})})
B10_{1} = Polygon({A10_{1}, A11_{1}, A11_{1} + (0, hei_{1}), A10_{1} + (0, hei_{1})})
B11_{1} = Polygon({A11_{1}, A12_{1}, A12_{1} + (0, hei_{1}), A11_{1} + (0, hei_{1})})
B12_{1} = Polygon({A12_{1}, A13_{1}, A13_{1} + (0, hei_{1}), A12_{1} + (0, hei_{1})})
B13_{1} = Polygon({A13_{1}, A14_{1}, A14_{1} + (0, hei_{1}), A13_{1} + (0, hei_{1})})
B14_{1} = Polygon({A14_{1}, A15_{1}, A15_{1} + (0, hei_{1}), A14_{1} + (0, hei_{1})})
B15_{1} = Polygon({A15_{1}, A16_{1}, A16_{1} + (0, hei_{1}), A15_{1} + (0, hei_{1})})
B16_{1} = Polygon({A16_{1}, A17_{1}, A17_{1} + (0, hei_{1}), A16_{1} + (0, hei_{1})})
B17_{1} = Polygon({A17_{1}, A18_{1}, A18_{1} + (0, hei_{1}), A17_{1} + (0, hei_{1})})
B18_{1} = Polygon({A18_{1}, A19_{1}, A19_{1} + (0, hei_{1}), A18_{1} + (0, hei_{1})})
B19_{1} = Polygon({A19_{1}, A20_{1}, A20_{1} + (0, hei_{1}), A19_{1} + (0, hei_{1})})
B20_{1} = Polygon({A20_{1}, A21_{1}, A21_{1} + (0, hei_{1}), A20_{1} + (0, hei_{1})})
B21_{1} = Polygon({A21_{1}, A22_{1}, A22_{1} + (0, hei_{1}), A21_{1} + (0, hei_{1})})
q1_{1} = Element(Take[{B1_{1}, B2_{1}, B3_{1}, B4_{1}, B5_{1}, B6_{1}, B7_{1}, B8_{1}, B9_{1}, B10_{1}, B11_{1}, B12_{1}, B13_{1}, B14_{1}, B15_{1}, B16_{1}, B17_{1}, B18_{1}, B19_{1}, B20_{1}}, 1, d2_{1}], If[n2_{1} ≟ d2_{1} - 1, d2_{1}, d2_{1} - 1])
Q11_{1}, Q12_{1}, Q13_{1}, Q14_{1} = Vertex(q1_{1})
pulsing2_{1} = 0.1 (slider from 0 to 1, step 0.1)
a_{1}: x(A_{1}) ≟ x(Element[chooseNum1_{1}, 3])
b_{1}: x(B_{1}) ≟ x(Element[chooseNum2_{1}, 2])
q1White_{1}: q1_{1}
q2White_{1}: q2_{1}
h_{1} = Segment(E_{1} + (0, 0.15), E_{1} - (0, 0.15))
i_{1} = Segment(F_{1} + (0, 0.15), F_{1} - (0, 0.15))
showgraph: showhint ∨ showsolution
tabOrder: {textQuestion, Menu, btnValidate, textHint, C_{1}, D1_{1}, D2_{1}, D3_{1}, D4_{1}, D5_{1}, D6_{1}, D7_{1}, D8_{1}, D9_{1}, D10_{1}, D11_{1}, D12_{1}, D13_{1}, D14_{1}, D15_{1}, D16_{1}, D17_{1}, D18_{1}, D19_{1}, D20_{1}, D_{1}, B1_{1}, B2_{1}, B3_{1}, B4_{1}, B5_{1}, B6_{1}, B7_{1}, B8_{1}, B9_{1}, B10_{1}, B11_{1}, B12_{1}, B13_{1}, B14_{1}, B15_{1}, B16_{1}, B17_{1}, B18_{1}, B19_{1}, B20_{1}, textSolution, textCountCorrect, btnNew}

Tool: PixelsToPoint
PixelsToPoint(Corner1,Corner3,Corner5,PixelCoords)
Input: Corner1, Corner3, Corner5, InputPixels
Output: OutputPoint

InputPixels: (100, 200)
xRight: x(Corner3)
xLeft: x(Corner1)
yTop: y(Corner3)
yBottom: y(Corner1)
yCoord: yTop - (y(InputPixels) / y(Corner5) * (yTop - yBottom))
xCoord: (x(InputPixels) / x(Corner5) * (xRight - xLeft)) + xLeft
OutputPoint: (xCoord, yCoord)

Tool: expandSegment
expandSegment(A,B,pixelGap,Corner1,Corner3,Corner5)
Input: A, B, pixelGap, Corner1, Corner3, Corner5
Output: newPoly

distanceX: (pixelGap / x(Corner5) * (x(Corner3) - x(Corner1)))
distanceY: (pixelGap / y(Corner5) * (y(Corner3) - y(Corner1)))
pointGap: distanceX
xyScale: distanceY / distanceX
A: (0, 0)
vecAB: B - A
pVec: (20 * UnitVector[(((-y(vecAB))) / xyScale, (x(vecAB) * xyScale))])
pVecAngle = Angle(xAxis, Line[(0, 0), pVec])
realAngle = If(pVecAngle ≟ pi / 2 ∨ pVecAngle ≟ (3 * pi / 2), pVecAngle, atand(tan(pVecAngle) / xyScale))
curveFunction = CurveCartesian((pointGap * cos(u)), ((pointGap * xyScale) * sin(u)), u, 0, (2 * pi))
K: curveFunction(realAngle)
vSpace = Vector(K)
allPoints: {A + vSpace, A - vSpace, B - vSpace, B + vSpace}
newPoly = Polygon(allPoints)

Tool: onboardingTextOffset
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)

Tool: onboardingTextOffset (command onboardingTextOffset1)
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)

Tool: onboardingTextOffset (command onboardingTextOffset11)
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)

Tool: circlePixels
circlePixels(A,pixelRadius,Corner1,Corner3,Corner5
Input: A, pixelRadius, Corner1, Corner3, Corner5
Output: newCircle

pointRadius: (pixelRadius / x(Corner5) * (x(Corner3) - x(Corner1)))
newCircle = Circle(A, pointRadius)

Tool: onboardingTextOffset (command onboardingTextOffset2)
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)

Tool: circlePixels (command circlePixels1)
circlePixels(A,pixelRadius,Corner1,Corner3,Corner5
Input: A, pixelRadius, Corner1, Corner3, Corner5
Output: newCircle

pointRadius: (pixelRadius / x(Corner5) * (x(Corner3) - x(Corner1)))
newCircle = Circle(A, pointRadius)

Tool: onboardingTextOffset (command onboardingTextOffset3)
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)

Tool: onboardingTextOffset (command onboardingTextOffset12)
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)

Tool: circlePixels (command circlePixels2)
circlePixels(A,pixelRadius,Corner1,Corner3,Corner5
Input: A, pixelRadius, Corner1, Corner3, Corner5
Output: newCircle

pointRadius: (pixelRadius / x(Corner5) * (x(Corner3) - x(Corner1)))
newCircle = Circle(A, pointRadius)

Tool: circlePixels (command circlePixels3)
circlePixels(A,pixelRadius,Corner1,Corner3,Corner5
Input: A, pixelRadius, Corner1, Corner3, Corner5
Output: newCircle

pointRadius: (pixelRadius / x(Corner5) * (x(Corner3) - x(Corner1)))
newCircle = Circle(A, pointRadius)

Tool: onboardingTextOffset (command onboardingTextOffset4)
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)