diff --git a/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/en_us.flatten.json5 b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/en_us.flatten.json5
new file mode 100644
index 000000000000..faedaacecebd
--- /dev/null
+++ b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/en_us.flatten.json5
@@ -0,0 +1,192 @@
+{
+  "pages.hextrapats":{
+    "hextrapats_consts.title": "Hextra Constants",
+    "hextrapats_logic.title": "Hextra Logic",
+    "hextrapats_nocon.title": "Non-consuming Logic",
+    "hextrapats_vec_literals.title": "Vector Literals",
+    "hextrapats_math.title": "Hextra Math",
+    "hextrapats_vec_math.title": "Hextra Vector Math",
+    "hextrapats_lists.title": "Hextra Lists",
+  },
+  hextrapats: {
+    page: {
+      consts: {
+        one: "The left-hand counter-clockwise pattern adds (1, 1, 1) to the stack; the right-hand clockwise pattern adds (-1, -1, -1)."
+      },
+      logic: {
+        greater: "If the first vector is longer than the second, return True. Otherwise, return False.",
+        less: "If the first vector is shorter than the second, return True. Otherwise, return False.",
+        greater_eq: "If the first vector is longer or the same length as the second, return True. Otherwise, return False.",
+        less_eq: "If the first vector is shorter or the same length as the second, return True. Otherwise, return False.",
+        len_eq: "If the two vectors are the same length (within small tolerance), return True. Otherwise, return False.",
+        len_neq: "If the two vectors are not the same length (outside small tolerance), return True. Otherwise, return False.",
+        in_range: "If the first number is between the second and third, return True. Otherwise, return False. If the first value is a vector, compare its length instead.",
+        "in_range.ops": "The fourth number seems to describe how to check if the value is in the range.$(li)0: min < val < max$(li)1: min <= val < max$(li)2: min < val <= max$(li)3: min <= val <= max",
+        out_range: "If the first number is not between the second and third, return True. Otherwise, return False. If the first value is a vector, compare its length instead.",
+        "out_range.ops": "The fourth number seems to describe how to check if the value is outside the range.$(li)0: val < min or max < val$(li)1: val <= min or max < val$(li)2: val < min or max <= val$(li)3: val <= min or max <= val"
+      },
+      nocon: {
+        intro: "Sometimes, I want operate on two iotas after comparing them, but it gets rather annoying to have to execute $(l:patterns/stackmanip#hexcasting:2dup)$(action)Dioscuri Gambit/$ every time I do.",
+        name: "Comparison Gambit",
+        detail: "With some experimentation, I have found that prepending a comparison with a clockwise triangle will cause the two inputs to not be consumed.",
+      },
+      vec_literals: {
+        intro: "Interestingly, attaching the tail of any Vector Reflection to the start of $(l:patterns/numbers)$(action)Number Reflection/$ makes it return a vector.",
+        x: "A head that sharply bends to the left will output a vector along the $(l:patterns/consts#hexcasting:const/vec/x)$(action)X axis/$.",
+        y: "A head that doesn't bend will output a vector along the $(l:patterns/consts#hexcasting:const/vec/y)$(action)Y axis/$.",
+        z: "A head that sharply bends to the right will output a vector along the $(l:patterns/consts#hexcasting:const/vec/z)$(action)Z axis/$.",
+        "1": "A head that slightly bends to the left will output a vector where $(l:patterns/hextrapats_consts#hextrapats:haha_ha_one)$(action)all 3 components are the same/$.",
+        detail: "First, I draw one of the eight shapes shown on the prior pages. Next, the $(italic)angles/$ following will modify a running count starting at 0.$(li)Forward: Add 1$(li)Left: Add 5$(li)Right: Add 10$(li)Sharp Left: Multiply by 2$(li)Sharp Right: Divide by 2.$(br)The clockwise version of the pattern, on the right of the other page, will negate the value at the very end. (The left-hand counter-clockwise version keeps the number positive).$(p)Once I finish drawing, a vector's pushed to the top of the stack.",
+
+        example: {
+          "x10.header": "Example 1",
+          "x10": "This pattern pushes (10, 0, 0).",
+          "y7.header": "Example 2",
+          "y7": "This pattern pushes (0, 7, 0): 5 + 1 + 1.",
+          "z-32.header": "Example 3",
+          "z-32": "This pattern pushes (0, 0, -32): negate 1 + 5 + 10 * 2.",
+          "a4.5.header": "Example 4",
+          "a4.5": "This pattern pushes (4.5, 4.5, 4.5): 5 / 2 + 1 + 1."
+        }
+      },
+      math: {
+        deg_to_rad: "Converts an angle in degrees to an angle in radians. Essentially multiplies by $(l:patterns/consts#hexcasting:const/double/pi)$(action)pi/$ then divides by 180.",
+        rad_to_deg: "Converts an angle in radians to an angle in degrees. Essentially multiplies by 180 then divides by $(l:patterns/consts#hexcasting:const/double/pi)$(action)pi/$.",
+        invert: "Multiplies the number/vector by -1.",
+        increment: "Adds 1.",
+        decrement: "Subtracts by 1.",
+        rand_zero: "Returns a random number between 0 (inclusive) and the number (exclusive).",
+        rand_range: "Returns a random number between the first number (inclusive) and the second (exclusive).",
+        scientific_exp: "Multiplies the input by 10^n or 10^-n, where n is the length of the tail, depending on whether the start is similar to $(l:patterns/math#hexcasting:mul)$(action)Mult. Dstl./$ or $(l:patterns/math#hexcasting:div)$(action)Div. Dstl./$. The top 3 patterns are x10^1, x10^2, and x10^3. The bottom 3 are x10^-1, x10^-2, and x10^-3.",
+        linear_approach: "Makes the first value approach the second at a rate of the third value. Will not overshoot.",
+        angle_dist: "Returns the shortest angular distance between two angles in radians.",
+        angle_approach: "Makes the first angle approach the second at a rate of the third value. Will not overshoot. Picks whichever direction is shorter. All angles in radians."
+      },
+      vec_math: {
+        normalize: "Sets the length of the vector to one.",
+        increment: "Increases length by 1. Does nothing if the vector is (0, 0, 0).",
+        decrement: "Decreases length by 1. Does nothing if the vector is (0, 0, 0).",
+        rand_vec: "Returns a unit vector facing a random direction.",
+        vec_dist: "Returns the distance between two vectors.",
+        vec_approach: "Moves the first vector towards the second a rate of the third value. Will not overshoot.",
+        vec_angle_dist: "Returns the shortest angular distance on a sphere between two vectors in radians",
+        vec_rotate_towards: "Turns the first vector towards the second vector by num radians.",
+        from_polar: "Creates a unit vector from two polar angles, pitch and yaw, in radians. +Y is up. 0 yaw is +Z, pi/2 yaw is -X. Yet again, mentions of $(thing)F3/$ turn up.",
+        to_polar: "Converts a vector's direction into two polar angles, pitch and yaw, in radians. +Y is up. 0 yaw is +Z, pi/2 yaw is -X. Yet again, mentions of $(thing)F3/$ turn up.",
+        rot_about_x: "Rotates the vector by the given angle in radians around the X axis.",
+        rot_about_y: "Rotates the vector by the given angle in radians around the Y axis.",
+        rot_about_z: "Rotates the vector by the given angle in radians around the Z axis.",
+        cons_about_x: "Converts an angle in radians to a unit vector where X=0. +Z at 0 radians and +Y at pi/4 radians.",
+        cons_about_y: "Converts an angle in radians to a unit vector where Y=0. +Z at 0 radians and -X at pi/4 radians. I've seen some texts related to this pattern mentioning something called $(thing)F3/$, but I couldn't figure out what that means.",
+        cons_about_z: "Converts an angle in radians to a unit vector where Z=0. -X at 0 radians and +Y at pi/4 radians.",
+      },
+      lists: {
+        split: "Splits a list at the given index. [a, b, c, d, e], 2 will return [a, b], [c, d, e].",
+        "del_element/": {
+          first: "Remove the iota at the top of the stack, then remove the first instance of it from the list. If that iota was in the list, return True. Otherwise, return False.",
+          all: "Remove the iota at the top of the stack, then remove $(italic)all/$ instances of it from the list. Returns the number of removed occurrences."
+        },
+        swindle: "Reorders the elements of a list the same way $(l:patterns/stackmanip#hexcasting:swizzle)$(action)Swindler's Gambit/$ reorders the stack. Inputting a negative code will reorder the elements at the start instead of the end.",
+        scronglwfijspoivjqwofklcrvewb: "Shuffles the order of elements in the list."
+      }
+    }
+  },
+  hexcasting: {
+    action: {
+      "hextrapats:": {
+        haha_ha_one: "Vector Reflection +1",
+        eno_ah_ahah: "Vector Reflection -1",
+
+        len_eq: "Length Equality Distillation",
+        len_neq: "Length Inequality Distillation",
+
+        in_range: "Range Exaltation",
+        out_range: "Range Exaltation II",
+
+        scaled_vec_x: "Vector Reflection X II",
+        scaled_vec_y: "Vector Reflection Y II",
+        scaled_vec_z: "Vector Reflection Z II",
+        scaled_vec_all: "Vector Reflection 1 II",
+
+        deg_to_rad: "Radian Purification",
+        rad_to_deg: "Degree Purification",
+        invert: "Reflection Purification",
+        increment: "Incrementation Purification",
+        decrement: "Decrementation Purification",
+        rand_zero: "Entropy Purification",
+        rand_range: "Entropy Distillation",
+        scientific_exp: "Scientific Purification",
+        linear_approach: "Approach Exaltation",
+        angle_dist: "Theta Distillation",
+        angle_approach: "Turning Exaltation",
+        vec_angle_dist: "Theta Distillation II",
+        vec_rotate_towards: "Turning Exaltation II",
+
+        normalize: "Norm Purification",
+        rand_vec: "Chaos Reflection",
+        vec_dist: "Distance Distillation",
+        vec_approach: "Approach Exaltation II",
+        from_polar: "Polar Distillation",
+        to_polar: "Polar Decomposition",
+        rot_about_x: "Pitch Distillation",
+        rot_about_y: "Yaw Distillation",
+        rot_about_z: "Roll Distillation",
+        cons_about_x: "Pitch Purification",
+        cons_about_y: "Yaw Purification",
+        cons_about_z: "Roll Purification",
+
+        "nocon/": {
+          greater: "Comparison Gambit: Maximus",
+          less: "Comparison Gambit: Minimus",
+          greater_eq: "Comparison Gambit: Maximus II",
+          less_eq: "Comparison Gambit: Minimus II",
+          eq: "Comparison Gambit: Equality",
+          neq: "Comparison Gambit: Inequality",
+          len_eq: "Comparison Gambit: Length Equality",
+          len_neq: "Comparison Gambit: Length Inequality",
+        },
+
+        split_list: "Separation Gambit",
+        "del_element/": {
+          first: "Elimination Gambit",
+          all: "Elimination Gambit II"
+        },
+        swindle_list: "Swindler's Distillation",
+        scronglwfijspoivjqwofklcrvewb: "Shuffling Purification"
+      },
+
+      "book.hextrapats:": {
+        haha_ha_one:  "Vector Rfln. +1/-1",
+
+        len_eq: "Length Equality Dstl.",
+        len_neq: "Length Inequality Dstl.",
+
+        scaled_vec_x: "Vector Rfln. +X/-X II",
+        scaled_vec_y: "Vector Rfln. +Y/-Y II",
+        scaled_vec_z: "Vector Rfln. +Z/-Z II",
+        scaled_vec_all: "Vector Rfln. +1/-1 II",
+
+        increment: "Incrementation Purif.",
+        decrement: "Decrementation Purif.",
+
+        "nocon/": {
+          greater: "Comp. Gambit: Maximus",
+          less: "Comp. Gambit: Minimus",
+          greater_eq: "Comp. Gambit: Maximus II",
+          less_eq: "Comp. Gambit: Minimus II",
+          eq: "Comp. Gambit: Equality",
+          neq: "Comp. Gambit: Inequality",
+          len_eq: "Comp. Gambit: Len. Eq.",
+          len_neq: "Comp. Gambit: Len. Ineq."
+        }
+      }
+    },
+    "special.hextrapats:": {
+      scaled_vec_x: "Vector Reflection: (%s, 0, 0)",
+      scaled_vec_y: "Vector Reflection: (0, %s, 0)",
+      scaled_vec_z: "Vector Reflection: (0, 0, %s)",
+      scaled_vec_all: "Vector Reflection: (%s, %s, %s)",
+      scientific_exp: "Scientific Purification: 10^%s"
+    }
+  }
+}
diff --git a/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/zh_cn.flatten.json5 b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/zh_cn.flatten.json5
new file mode 100644
index 000000000000..db350628a43b
--- /dev/null
+++ b/projects/1.20-fabric/assets/modrinth-hextra-patterns/hextrapats/lang/zh_cn.flatten.json5
@@ -0,0 +1,192 @@
+{
+  "pages.hextrapats":{
+    "hextrapats_consts.title": "咒法新增：常量",
+    "hextrapats_logic.title": "咒法新增：逻辑",
+    "hextrapats_nocon.title": "保留式比较",
+    "hextrapats_vec_literals.title": "向量常量",
+    "hextrapats_math.title": "咒法新增：数学",
+    "hextrapats_vec_math.title": "咒法新增：向量数学",
+    "hextrapats_lists.title": "咒法新增：列表",
+  },
+  hextrapats: {
+    page: {
+      consts: {
+        one: "左图即逆时针图案会压入 (1, 1, 1)；右图即顺时针图案会压入 (-1, -1, -1)。"
+      },
+      logic: {
+        greater: "若第一个向量的长度长于第二个的，返回 True；否则返回 False。",
+        less: "若第一个向量的长度短于第二个的，返回 True；否则返回 False。",
+        greater_eq: "若第一个向量的长度长于或等于第二个的，返回 True；否则返回 False。",
+        less_eq: "若第一个向量的长度短于或等于第二个的，返回 True；否则返回 False。",
+        len_eq: "若两向量的长度相等（允许较小误差），返回 True；否则返回 False。",
+        len_neq: "若两向量的长度不相等（不计较小误差），返回 True；否则返回 False。",
+        in_range: "若第一个数在第二个和第三个之间，返回 True；否则返回 False。若第一个参数是向量，则比较其长度。",
+        "in_range.ops": "第四个数似乎描述了检验的方式。$(li)0：min < val < max$(li)1：min <= val < max$(li)2：min < val <= max$(li)3：min <= val <= max",
+        out_range: "若第一个数不在第二个和第三个之间，返回 True；否则返回 False。若第一个参数是向量，则比较其长度。",
+        "out_range.ops": "第四个数似乎描述了检验的方式。$(li)0：val < min 或 max < val$(li)1：val <= min 或 max < val$(li)2：val < min 或 max <= val$(li)3：val <= min 或 max <= val"
+      },
+      nocon: {
+        intro: "总有些时候，我会想要在比较两个 iota 之后还继续对它们执行操作，但这就需要每次都先运行$(l:patterns/stackmanip#hexcasting:2dup)$(action)狄俄斯库里之策略/$，确实有些麻烦。",
+        name: "比较之策略",
+        detail: "通过实验，我发现：在比较图案前加上一个顺时针的三角形，就可以保留两个输入参数了。",
+      },
+      vec_literals: {
+        intro: "返回数的图案有种神奇的性质：把向量之精思的尾部加到$(l:patterns/numbers)$(action)数之精思/$的开头，就能返回一个向量。",
+        x: "指向左后方的头部会返回 $(l:patterns/consts#hexcasting:const/vec/x)$(action)X 轴/$上的向量。",
+        y: "直线形状的头部会返回 $(l:patterns/consts#hexcasting:const/vec/y)$(action)Y 轴/$上的向量。",
+        z: "指向右后方的头部会返回 $(l:patterns/consts#hexcasting:const/vec/z)$(action)Z 轴/$上的向量。",
+        "1": "向左微偏的头部会返回$(l:patterns/hextrapats_consts#hextrapats:haha_ha_one)$(action)所有 3 个分量都相等/$的向量。",
+        detail: "首先，绘制前页八种图案中的一种，默认数值为 0。然后，每一画的$(italic)方向/$会以对应方式修改该数值。$(li)前方：加 1$(li)左前方：加 5$(li)右前方：加 10$(li)左后方：乘 2$(li)右后方：除以 2$(br)顺时针绘制，也即各页右图，会在绘制完成后取相反数（如左图逆时针绘制则不取）。$(p)绘制完成后会返回对应向量。",
+
+        example: {
+          "x10.header": "例图一",
+          "x10": "该图案会返回 (10, 0, 0)。",
+          "y7.header": "例图二",
+          "y7": "该图案会返回 (0, 7, 0)：5 + 1 + 1。",
+          "z-32.header": "例图三",
+          "z-32": "该图案会返回 (0, 0, -32)：(1 + 5 + 10) * 2 的相反数。",
+          "a4.5.header": "例图四",
+          "a4.5": "该图案会返回 (4.5, 4.5, 4.5)：5 / 2 + 1 + 1。"
+        }
+      },
+      math: {
+        deg_to_rad: "将角度变为弧度。相当于乘以 $(l:patterns/consts#hexcasting:const/double/pi)$(action)π/$ 再除以 180。",
+        rad_to_deg: "将弧度变为角度。相当于乘以 180 再除以 $(l:patterns/consts#hexcasting:const/double/pi)$(action)π/$。",
+        invert: "求所给数/向量与 -1 相乘的积。",
+        increment: "递增 1。",
+        decrement: "递减 1。",
+        rand_zero: "返回 0（包含）到所给数（不包含）之间的随机数。",
+        rand_range: "返回从第一个数（包含）到第二个数（不包含）之间的随机数。",
+        scientific_exp: "求所给数/向量与 10^n 或 10^-n 相乘的积。其中 n 为尾部的长度，指数有无负号取决于图案开头更近似于$(l:patterns/math#hexcasting:mul)$(action)乘法之馏化/$还是$(l:patterns/math#hexcasting:div)$(action)除法之馏化/$。上方三图分别为 x10^1、x10^2、x10^3。下方三图分别为 x10^-1、x10^-2、x10^-3。",
+        linear_approach: "以第三个数为步长，让第一个数向第二个数靠近，不会过冲。",
+        angle_dist: "返回两角间最短的角度差，以弧度计。",
+        angle_approach: "以第三个值为步长，让第一个角向第二个角靠近，不会过冲。会选择最短路径。所有角均以弧度计。"
+      },
+      vec_math: {
+        normalize: "将向量的长度变为 1。",
+        increment: "令长度增加 1。对 (0, 0, 0) 无效。",
+        decrement: "令强度减少 1。对 (0, 0, 0) 无效。",
+        rand_vec: "返回朝向随机方向的单位向量。",
+        vec_dist: "返回两向量间的距离。",
+        vec_approach: "以第三个值为步长，让第一个向量向第二个向量靠近，不会过冲。",
+        vec_angle_dist: "返回两向量间最短的角度差，以弧度计。",
+        vec_rotate_towards: "将第一个向量向第二个向量旋转 num 弧度。",
+        from_polar: "以俯仰和偏航两个极坐标角生成单位向量，均以弧度计。+Y 对应上方。偏航角为 0 对应 +Z，为 π/2 对应 -X。相关文献又提到了所谓的 $(thing)F3/$。",
+        to_polar: "将向量的方向转换为俯仰和偏航两个极坐标角，均以弧度计。+Y 对应上方。偏航角为 0 对应 +Z，为 π/2 对应 -X。相关文献又提到了所谓的 $(thing)F3/$。",
+        rot_about_x: "绕 X 轴将所给向量旋转所给弧度。",
+        rot_about_y: "绕 Y 轴将所给向量旋转所给弧度。",
+        rot_about_z: "绕 Z 轴将所给向量旋转所给弧度。",
+        cons_about_x: "将弧度角变为单位向量。该向量的 X 分量为 0。0 弧度对应 +Z，π/4 弧度对应 +Y。",
+        cons_about_y: "将弧度角变为单位向量。该向量的 Y 分量为 0。0 弧度对应 +Z，π/4 弧度对应 -X。我曾读到过某些文献提到某种叫 $(thing)F3/$ 的东西，但我还找不出它的意义。",
+        cons_about_z: "将弧度角变为单位向量。该向量的 Z 分量为 0。0 弧度对应 -X，π/4 弧度对应 +Y。",
+      },
+      lists: {
+        split: "在所给下标处分割列表。[a, b, c, d, e], 2 会返回 [a, b], [c, d, e]。",
+        "del_element/": {
+          first: "移除栈顶 iota，而后移除列表中该 iota 第一次出现的实例。若列表中存在该 iota，返回 True；否则返回 False。",
+          all: "移除栈顶 iota，而后移除列表中该 iota 的$(italic)全部/$实例。返回从列表中移除的元素数量。"
+        },
+        swindle: "重排列表的元素，方式与$(l:patterns/stackmanip#hexcasting:swizzle)$(action)骗徒之策略/$重排栈的一致。给定负值会从开头起进行重排，而非从末尾起。",
+        scronglwfijspoivjqwofklcrvewb: "打乱列表各元素。"
+      }
+    }
+  },
+  hexcasting: {
+    action: {
+      "hextrapats:": {
+        haha_ha_one: "向量之精思，+1型",
+        eno_ah_ahah: "向量之精思，-1型",
+
+        len_eq: "长度相等之馏化",
+        len_neq: "长度不等之馏化",
+
+        in_range: "范围之提整",
+        out_range: "范围之提整，第二型",
+
+        scaled_vec_x: "向量之精思，X第二型",
+        scaled_vec_y: "向量之精思，Y第二型",
+        scaled_vec_z: "向量之精思，Z第二型",
+        scaled_vec_all: "向量之精思，1第二型",
+
+        deg_to_rad: "弧度之纯化",
+        rad_to_deg: "角度之纯化",
+        invert: "反照之纯化",
+        increment: "递增之纯化",
+        decrement: "递减之纯化",
+        rand_zero: "熵之纯化",
+        rand_range: "熵之馏化",
+        scientific_exp: "科学计数之纯化",
+        linear_approach: "趋近之提整",
+        angle_dist: "西塔之馏化",
+        angle_approach: "转向之提整",
+        vec_angle_dist: "西塔之馏化，第二型",
+        vec_rotate_towards: "转向之提整，第二型",
+
+        normalize: "归一之纯化",
+        rand_vec: "混沌之精思",
+        vec_dist: "距离之馏化",
+        vec_approach: "趋近之提整，第二型",
+        from_polar: "极坐标之馏化",
+        to_polar: "极坐标之分解",
+        rot_about_x: "俯仰之馏化",
+        rot_about_y: "偏航之馏化",
+        rot_about_z: "滚转之馏化",
+        cons_about_x: "俯仰之纯化",
+        cons_about_y: "偏航之纯化",
+        cons_about_z: "滚转之纯化",
+
+        "nocon/": {
+          greater: "比较之策略：至大",
+          less: "比较之策略：至小",
+          greater_eq: "比较之策略：至大第二型",
+          less_eq: "比较之策略：至小第二型",
+          eq: "比较之策略：相等",
+          neq: "比较之策略：不等",
+          len_eq: "比较之策略：长度相等",
+          len_neq: "比较之策略：长度不等",
+        },
+
+        split_list: "分割之策略",
+        "del_element/": {
+          first: "消除之策略",
+          all: "消除之策略，第二型"
+        },
+        swindle_list: "骗徒之馏化",
+        scronglwfijspoivjqwofklcrvewb: "打乱之纯化"
+      },
+
+      "book.hextrapats:": {
+        haha_ha_one:  "向量之精思，+1/-1型",
+
+        len_eq: "长度相等之馏化",
+        len_neq: "长度不等之馏化",
+
+        scaled_vec_x: "向量之精思，+X/-X第二型",
+        scaled_vec_y: "向量之精思，+Y/-Y第二型",
+        scaled_vec_z: "向量之精思，+Z/-Z第二型",
+        scaled_vec_all: "向量之精思，+1/-1第二型",
+
+        increment: "递增之纯化",
+        decrement: "递减之纯化",
+
+        "nocon/": {
+          greater: "比较之策略：至大",
+          less: "比较之策略：至小",
+          greater_eq: "比较之策略：至大第二型",
+          less_eq: "比较之策略：至小第二型",
+          eq: "比较之策略：相等",
+          neq: "比较之策略：不等",
+          len_eq: "比较之策略：长度相等",
+          len_neq: "比较之策略：长度不等"
+        }
+      }
+    },
+    "special.hextrapats:": {
+      scaled_vec_x: "向量之精思：(%s, 0, 0)",
+      scaled_vec_y: "向量之精思：(0, %s, 0)",
+      scaled_vec_z: "向量之精思：(0, 0, %s)",
+      scaled_vec_all: "向量之精思：(%s, %s, %s)",
+      scientific_exp: "科学计数之纯化：10^%s"
+    }
+  }
+}