number of vertices of the polygon

1= translation, 2=reflection, 3=Rotation

$\textsf{A}$

#4D4D4D

$\text{Check}$

$\text{NEW PROBLEM}$

Fix position and allow selection for all text objects

\text{This is the answer.}

\text{\bold{Solution}\
See the transformed figure on the right.}

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

#eeeeee

#2E006758

#2EB00020

\text{This is some additional info}

$\textsf{NEXT STEP}$

$\textsf{ANIMATE}$

$\textsf{RESTART}$

Previous step

inactivateButtons

\text{Click to animate}

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

Cen2: (0, 0)
vectors4All = Shuffle({(1, 0), (2, 0), (1, -1), (1, -2), (2, -2), (2, -1), (0, -1), (0, -2)})
vectors1All = Shuffle({(1, 0), (2, 0), (1, 1), (1, 2), (2, 2), (2, 1), (0, 1), (0, 2)})
vectors2All = Shuffle({(-1, 0), (-2, 0), (-1, 1), (-1, 2), (-2, 2), (-2, 1), (0, 1), (0, 2)})
RandomXA = Shuffle({-5, -3, 1, 3})
lines = Shuffle({y = x, y = (-x), y = 0, x = 0})
vectors3All = Shuffle({(-1, 0), (-2, 0), (-1, -1), (-1, -2), (-2, -2), (-2, -1), (0, -1), (0, -2)})
vectorsAll: {vectors1All, vectors2All, vectors3All, vectors4All}
vectors1evens = Shuffle({(2, 0), (2, 2), (0, 2)})
vectors2evens = Shuffle({(-2, 0), (-2, 2), (0, 2)})
vectors3evens = Shuffle({(-2, 0), (-2, -2), (0, -2)})
randomList2 = Shuffle({3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 6})
vectors4evens = Shuffle({(2, 0), (2, -2), (0, -2)})
randomList1 = Shuffle({1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3})
countQuestion = 0 (slider from -5 to 10000, step 1)
cents: {Shuffle[{(4, 4), (4, 5), (5, 5), (5, 4)}], Shuffle[{(6, 4), (6, 5), (5, 5), (6, 4)}], Shuffle[{(6, 6), (5, 6), (5, 5), (6, 4)}], Shuffle[{(4, 6), (4, 5), (5, 5), (5, 6)}]}
xA = Element(RandomXA, Mod[countQuestion, Length[RandomXA]] + 1)
RandomYA = Shuffle({-5, -3, 1, 3} \ {xA, (-xA)})
A1 = If(countQuestion ≟ 0, (3, 1), (xA, Element[RandomYA, Mod[countQuestion, Length[RandomYA]] + 1]))
triangles = Shuffle({{A1, A1 + (1, 0), A1 + (1, 1)}, {A1, A1 + (2, 0), A1 + (2, 1)}, {A1, A1 + (2, 0), A1 + (1, 1)}, {A1, A1 + (1, 0), A1 + (1, 2)}, {A1, A1 + (1, 0), A1 + (2, 1)}})
pents = Shuffle({{A1, A1 + (2, 0), A1 + (2, 1), A1 + (1, 2), A1 + (0, 1)}, {A1, A1 + (1, 0), A1 + (2, 1), A1 + (1, 2), A1 + (0, 1)}, {A1, A1 + (1, 1), A1 + (1, 2), A1 + (-1, 2), A1 + (-1, 1)}, {A1, A1 + (2, 0), A1 + (3, 1), A1 + (1, 2), A1 + (-1, 1)}})
quads = Shuffle({{A1, A1 + (1, 0), A1 + (1, 1), A1 + (0, 1)}, {A1, A1 + (2, 0), A1 + (2, 1), A1 + (0, 1)}, {A1, A1 + (1, 0), A1 + (1, 2), A1 + (0, 2)}, {A1, A1 + (1, 0), A1 + (2, 1), A1 + (1, 1)}, {A1, A1 + (2, 0), A1 + (3, 1), A1 + (1, 1)}})
hexs = Shuffle({{A1, A1 + (1, 1), A1 + (1, 2), A1 + (0, 3), A1 + (-1, 2), A1 + (-1, 1)}, {A1, A1 + (1, -1), A1 + (2, -1), A1 + (3, 0), A1 + (2, 1), A1 + (1, 1)}})
AInReg = If(x(A1) ≤ 0 ∧ y(A1) ≤ 0, 1, x(A1) > 0 ∧ y(A1) ≤ 0, 2, x(A1) > 0 ∧ y(A1) > 0, 3, 4)
lin1 = If(AInReg ≟ 1 ∨ AInReg ≟ 3, Element[lines \ {y = x}, Mod[countQuestion, 3] + 1], Element[lines \ {y = (-x)}, Mod[countQuestion, 3] + 1])
A1Ref1 = Mirror(A1, lin1)
vectorsevens: {vectors1evens, vectors2evens, vectors3evens, vectors4evens}
randomNum11 = Element(randomList1, Mod[countQuestion, Length[randomList1]] + 1)
randomNum12 = Element(randomList1, Mod[countQuestion + randomNum11, Length[randomList1]] + 1)
angles: {90°, 180°, 270°}
ang2 = Element(angles, Mod[countQuestion + 1, Length[angles]] + 1)
ang1 = Element(angles, Mod[countQuestion, Length[angles]] + 1)
Level = 1
vec1 = Element(If[Level ≟ 1, vectorsAll(AInReg), vectorsevens(AInReg)], Mod[countQuestion, Length[vectorsevens(AInReg)]] + 1)
A1T1 = Translate(A1, vec1)
Cen1: (0, 0)
A1Rot1 = Rotate(A1, ang1, Cen1)
B = Element({A1T1, A1Ref1, A1Rot1}, randomNum11)
BRot = Rotate(B, ang2, Cen2)
BInReg = If(x(B) ≤ 0 ∧ y(B) ≤ 0, 1, x(B) > 0 ∧ y(B) ≤ 0, 2, x(B) > 0 ∧ y(B) > 0, 3, 4)
vec2 = Element(If[Level ≟ 2, vectorsAll(BInReg), vectorsevens(BInReg)], Mod[countQuestion, Length[vectorsevens(BInReg)]] + 1)
BT = Translate(B, vec2)
lin2 = If(BInReg ≟ 1 ∨ BInReg ≟ 3, Element[lines \ {y = x}, Mod[countQuestion + 1, 3] + 1], Element[lines \ {y = (-x)}, Mod[countQuestion + 1, 3] + 1])
Bref = Mirror(B, lin2)
C = Element({BT, Bref, BRot}, randomNum12)
CInReg = If(x(C) ≤ 0 ∧ y(C) ≤ 0, 1, x(C) > 0 ∧ y(C) ≤ 0, 2, x(C) > 0 ∧ y(C) > 0, 3, 4)
randomNum2 = Element(randomList2, Mod[countQuestion, Length[randomList2]] + 1)
A4: A1 + (2, 1)
A5: A1 + (1, 1)
A6: A1 + (0, 1)
A3: A1 + (2, 0)
A2: A1 + (1, 0)
VerticesShuf = Element(Element[{triangles, quads, pents, hexs}, randomNum2 - 2], 1)
B6 = (-4, -4)
B5 = (-4, -5)
B4 = (-5, -5)
B3 = (-5, -4)
B2 = (-5, -3)
B1: (-4, -3)
countCorrect = 0
ang3 = Element(angles, Mod[countQuestion + 2, Length[angles]] + 1)
lin3 = If(CInReg ≟ 1 ∨ CInReg ≟ 3, Element[lines \ {y = x}, Mod[countQuestion + 2, 3] + 1], Element[lines \ {y = (-x)}, Mod[countQuestion + 2, 3] + 1])
randomNum13 = Element(randomList1, Mod[countQuestion + randomNum2, Length[randomList1]] + 1)
studPoly = Polygon(Take[{B1, B2, B3, B4, B5, B6}, 1, randomNum2])
inputPoint: (0, 1)
Cen3: (0, 0)
vec3 = Element(If[Level ≟ 3, vectorsAll(CInReg), vectorsevens(CInReg)], Mod[countQuestion, Length[vectorsevens(CInReg)]] + 1)
q1 = Polygon(VerticesShuf)
q1Rot1 = Rotate(q1, If[ang1 ≟ 270°, -90°, ang1], Cen1)
q1Ref1 = Mirror(q1, lin1)
q1T1 = Translate(q1, vec1)
q2 = Element({q1T1, q1Ref1, q1Rot1}, randomNum11)
q2Ref = Mirror(q2, lin2)
q2Rot = Rotate(q2, If[ang2 ≟ 270°, -90°, ang2], Cen2)
q2T = Translate(q2, vec2)
q3 = Element({q2T, q2Ref, q2Rot}, randomNum12)
q3Ref = Mirror(q3, lin3)
q3Rot = Rotate(q3, If[ang3 ≟ 270°, -90°, ang3], Cen3)
q3T = Translate(q3, vec3)
q4 = Element({q3T, q3Ref, q3Rot}, randomNum13)
qsol = Element({q2, q3, q4}, Level)
validate = false
showanswer = false
showsolution = false
tries = 0
showhint = false
correct = AreEqual(qsol, studPoly)
showbuttons = true
showhinttypicalerror = false
labelBtnValidate: "\text{CHECK (" + (LaTeX[3 - tries]) + ")}"
helpTextHint: "\text{" + (LaTeX[If[Level ≟ 1, If[randomNum11 ≟ 1, (("The vector " * vec1) * " is shown."), randomNum11 ≟ 2, "The reflection line is shown.", "The center of rotation and the\\angle are shown."], If[showhinttypicalerror, "You can see the transformation for\\one of the vertices.", "You can see the transformation\\for two vertices."]]]) + "}"
pixelsRight: 16
pixelsLeft: 16
pixelsBottom: 16 + 36 + 24 + 16 + 8
pixelsTop: 24 + 16 + 8
borderBox = Polygon({(-6.5, -6.5), (6.5, -6.5), (6.5, 6.5), (-6.5, 6.5)})
layoutY: 448
enableInput: tries < 3 ∧ (¬(validate ∧ correct))
layoutX: 170 + 24
layoutAppSize = Corner(5)
inputPointLastPos: (0, 1)
textCountCorrect: "\text{Number correct: " + (LaTeX[countCorrect]) + " }"
inputCurrent: {Vertex[studPoly]}
inputSaved: {(-4, -3), (-5, -3), (-5, -4)}
enableBtnValidate: inputCurrent ≠ inputSaved
textFeedback: "" + (LaTeX[If[correct, "$\text{✓ Correct}$", "$\text{✕ " + (If[tries < 3, "Try again", "Maybe next time"]) + "}$"]]) + ""
eq1: x = x(Corner[2]) - (x(Corner[2] - Corner[1]) / 800 * 16)
MoveGuideline = (-7.898868413966628, 0.1507167331115954)
hGuideline: y = y(MoveGuideline)
hGuideline' = Translate(hGuideline, Vector[(Vector[Corner[4], Corner[1]] / 500 * 16)])
l1: {Vertex[qsol]}
l2: {Vertex[studPoly]}
q1Black: q1
studPolyBlack: studPoly
qsolBlack: qsol
solutionVectors1 = Zip(Vector[AA, AA + vec1], AA, {Vertex[q1]})
step = 0
solutionVectors2 = Zip(Vector[AA, AA + vec2], AA, {Vertex[q2]})
solutionVectors3 = Zip(Vector[AA, AA + vec3], AA, {Vertex[q3]})
labelPol = Text("\textsf{A}", A1, true, true, -1, -1)
vec1Hint = Vector(Vertex[q1], Vertex[q1] + vec1)
Cen1Hint: Cen1
seg1Hint = Segment(Cen1, If[Vertex[q1, 1] ≠ Cen1, Vertex[q1, 1], Vertex[q1, 2]])
seg2Hint = Segment(Cen1, If[Vertex[q1, 1] ≠ Cen1, Vertex[q2, 1], Vertex[q2, 2]])
ang1Hint = Angle(seg1Hint, seg2Hint)
hintList = Take({Vertex[q1, 1], Vertex[q2, 1], Vertex[q3, 1], Vertex[q4, 1]}, 1, Level + 1)
hintList2 = Take({Vertex[q1, 2], Vertex[q2, 2], Vertex[q3, 2], Vertex[q4, 2]}, 1, Level + 1)
hintListLables2 = Zip(Text[(("Q_{" * nn) * "}"), PP, true, true, 1, -1], PP, hintList2, nn, Sequence[Level + 1])
segSolutionRot11 = Segment(Cen1, If[Vertex[q1, 1] ≠ Cen1, Vertex[q1, 1], Vertex[q1, 2]])
segSolutionRot21 = Segment(Cen2, If[Vertex[q2, 1] ≠ Cen2, Vertex[q2, 1], Vertex[q2, 2]])
segSolutionRot31 = Segment(Cen3, If[Vertex[q3, 1] ≠ Cen3, Vertex[q3, 1], Vertex[q3, 2]])
segSolutionRot12 = Segment(Cen1, If[Vertex[q1, 1] ≠ Cen1, Vertex[q2, 1], Vertex[q2, 2]])
segSolutionRot22 = Segment(Cen2, If[Vertex[q2, 1] ≠ Cen2, Vertex[q3, 1], Vertex[q3, 2]])
segSolutionRot32 = Segment(Cen3, If[Vertex[q3, 1] ≠ Cen3, Vertex[q4, 1], Vertex[q4, 2]])
angSolRot1 = Angle(segSolutionRot11, segSolutionRot12)
angSolRot2 = Angle(segSolutionRot21, segSolutionRot22)
angSolRot3 = Angle(segSolutionRot31, segSolutionRot32)
textHint: "\text{\color{" + (LaTeX[colorOrange]) + "}\bold{Hint}\\" + (LaTeX[If[showhint ∨ showhinttypicalerror, helpTextHint]]) + "}"
Cor1 = (-19.997405317338597, -8.838698954868695)
Cor3 = (7.106020929880172, 8.126288546507642)
isTypicalError: Level ≥ 2 ∧ (¬correct)
anim = 0 (slider from 0 to 1, step 0.01)
q1T1Anim = Translate(q1, (vec1 * anim))
q1Rot1Anim = Rotate(q1, (If[ang1 ≟ 270°, -90°, ang1] * anim), Cen1)
q1Ref1Anim = Polygon(Zip[Translate[AA, Vector[(anim * Vector[AA, Mirror[AA, lin1]])]], AA, VerticesShuf])
q2Anim = Element({q1T1Anim, q1Ref1Anim, q1Rot1Anim}, randomNum11)
speed: 3
q2TAnim = Translate(q2, (vec2 * anim))
q2RotAnim = Rotate(q2, (If[ang2 ≟ 270°, -90°, ang2] * anim), Cen2)
q2RefAnim = Polygon(Zip[Translate[AA, Vector[(anim * Vector[AA, Mirror[AA, lin2]])]], AA, {Vertex[q2]}])
q3Anim = Element({q2TAnim, q2RefAnim, q2RotAnim}, randomNum12)
q3TAnim = Translate(q3, (vec3 * anim))
q3RotAnim = Rotate(q3, (If[ang3 ≟ 270°, -90°, ang3] * anim), Cen3)
q3RefAnim = Polygon(Zip[Translate[AA, Vector[(anim * Vector[AA, Mirror[AA, lin3]])]], AA, {Vertex[q3]}])
q4Anim = Element({q3TAnim, q3RefAnim, q3RotAnim}, randomNum13)
fakexAxis = Segment((-6.45, 0), (6.45, 0))
fakeyAxis = Segment((0, -6.45), (0, 6.45))
labelx = Text("x\\", (6, 0.1), true, true, 1, 1)
labely = Text("y", (0.2, 6.1), true, true, 1, 1)
timer = 0 (slider from 0 to 1)
textQuestion: "\textsf{Drag the points to make the image of figure A \\after the following transformation" + (LaTeX[If[Level ≥ 2, "s", ""]]) + ":}\\\\\\" + (LaTeX[If[step ≟ 1, "\bold{", ""]]) + "" + (LaTeX[If[Level ≥ 2, "\textsf{1. }", ""]]) + "" + (LaTeX[If[randomNum11 ≟ 1, ("\textsf{Translation by the vector }" * vec1), randomNum11 ≟ 2, ("\textsf{Reflection across the line }" * lin1), ((((("\textsf{Rotation about }" * Cen1) * "\textsf{ of angle }\\") * If[Level ≥ 2, "\phantom{\textsf{1. }}", ""]) * "") * If[ang1 ≟ 90°, (ang1 * "\textsf{ counterclockwise}"), ang1 ≟ 180°, (ang1 * ""), "90°\textsf{ clockwise}"])]]) + "" + (LaTeX[If[step ≟ 1, "}", ""]]) + " \\" + (LaTeX[If[step ≟ 2, "\bold{", ""]]) + "" + (LaTeX[If[Level ≥ 2, "\textsf{2. }"]]) + "" + (LaTeX[If[Level ≥ 2, If[randomNum12 ≟ 1, ("\textsf{Translation by the vector }" * vec2), randomNum12 ≟ 2, ("\textsf{Reflection across the line }" * lin2), ((("\textsf{Rotation about }" * Cen2) * "\textsf{ of angle}\\\phantom{\textsf{2. }}") * If[ang2 ≟ 90°, (ang2 * "\textsf{ counterclockwise}"), ang2 ≟ 180°, (ang2 * ""), "90°\textsf{ clockwise}"])], ""]]) + "" + (LaTeX[If[step ≟ 2, "}", ""]]) + "
\\" + (LaTeX[If[step ≟ 3, "\bold{", ""]]) + "" + (LaTeX[If[Level ≥ 3, "\textsf{3. }"]]) + "" + (LaTeX[If[Level ≥ 3, If[randomNum13 ≟ 1, ("\textsf{Translation by the vector }" * vec3), randomNum13 ≟ 2, ("\textsf{Reflection across the line }" * lin3), ((("\textsf{Rotation about }" * Cen3) * "\textsf{ of angle}\\\phantom{\textsf{3. }}") * If[ang3 ≟ 90°, (ang3 * "\textsf{ counterclockwise}"), ang3 ≟ 180°, (ang3 * ""), "\textsf{90° clockwise}"])], ""]]) + "" + (LaTeX[If[step ≟ 3, "}", ""]]) + "
} "
animHint = 0 (slider from 0 to Level, step 0.01)
pulsingSpeed: 8
pulsing = 0.9 (slider from 0 to 1, step 0.1)
onboarding = true
onboardingX_{1}: 600
onboardingY_{1}: 100
onboardingCase_{1} = 1
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}]) + "}"
pulsingObject = circlePixels(B1, 7 + (7 * pulsing), Corner[1], Corner[3], Corner[5])
Hint12 = If(randomNum11 ≠ 3, Translate[hintList(1), Vector[(Vector[hintList(1), hintList(2)] * animHint)]], Rotate[hintList(1), ((animHint * angSolRot1) * If[ang1 ≟ 270°, -1, 1])])
Hint23 = If(randomNum12 ≠ 3, Translate[hintList(2), Vector[(Vector[hintList(2), hintList(3)] * (animHint - 1))]], Rotate[hintList(2), (((animHint - 1) * angSolRot2) * If[ang2 ≟ 270°, -1, 1])])
Hint34 = If(randomNum13 ≠ 3, Translate[hintList(3), Vector[(Vector[hintList(3), hintList(4)] * (animHint - 2))]], Rotate[hintList(3), (((animHint - 2) * angSolRot3) * If[ang3 ≟ 270°, -1, 1])])
vec2Hint = Vector(hintList(2), hintList(3))
vec3Hint = Vector(hintList(3), hintList(4))
gridh = Sequence(Segment[(-6.4, -6 + ii), (6.4, -6 + ii)], ii, 0, 12)
gridv = Sequence(Segment[(-6 + ii, -6.4), (-6 + ii, 6.4)], ii, 0, 12)
axisXnums = Zip(Text[((If[ii > 0, "\hspace{7}"] * ii) * If[ii ≟ 0, "\hspace{7}", ""]), (ii, 0), true, true, If[ii ≟ 0, -1, 0], -1], ii, Sequence[-6, 6, 2])
axisYnums = Zip(Text[ii, (0, ii), true, true, -1, 0], ii, Sequence[-6, 6, 2] \ {0})
labelAlignment: {-1, -1, If[hintList(1) ≟ hintList(3), 1, -1], If[hintList(4) ≟ hintList(1) ∨ hintList(4) ≟ hintList(2), 1, -1]}
labelHin1 = Text(1, hintList(1), true, true, 1, labelAlignment(1))
hintListLables = Zip(Text[If[nn ≟ 1, "", nn - 1], PP, true, true, 1, labelAlignment(nn)], PP, hintList, nn, Sequence[Level + 1])
lin1Hint: y = (0 * (-1))
labelHin2 = Text(1, hintList(2), true, true, 1, labelAlignment(2))
labelHin3 = Text(2, hintList(3), true, true, (-labelAlignment(3)), labelAlignment(3))
labelHin4 = Text(3, hintList(4), true, true, (-labelAlignment(4)), labelAlignment(4))

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: PixelsToPoint (command PixelsToPoint1)
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: PointToPixels
PointToPixels(Corner1,Corner3,Corner5,InputPoint)
Input: Corner1, Corner3, Corner5, InputPoint
Output: OutputPixels

Corner1: (-5, -5)
Corner3: (16, 6)
Corner5: (300, 200)
xLeft: x(Corner1)
xRight: x(Corner3)
yTop: y(Corner3)
yBottom: y(Corner1)
yPixels: (y(Corner5) * (y(InputPoint) - yBottom) / (yTop - yBottom))
xPixels: (x(Corner5) * (x(InputPoint) - xLeft) / (xRight - xLeft))
OutputPixels: (xPixels, yPixels)

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: 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)