json-as 0.5.52 → 0.5.56

package/assembly/src/util.ts

@@ -1,27 +1,23 @@
 import { StringSink } from "as-string-sink/assembly";
-import { CharCode, isSpace } from "util/string";
+import { isSpace } from "util/string";
 import { backSlashCode, quoteCode } from "./chars";
 
-// @ts-ignore
-@inline
-export function unsafeCharCodeAt(data: string, pos: i32): i32 {
+// @ts-ignore: Decorator
+@inline export function unsafeCharCodeAt(data: string, pos: i32): i32 {
   return load<u16>(changetype<usize>(data) + ((<usize>pos) << 1));
 }
 
-// @ts-ignore
-@inline
-export function removeWhitespace(data: string): string {
+// @ts-ignore: Decorator
+@inline export function removeWhitespace(data: string): string {
   const result = new StringSink();
   let instr = false;
   for (let i = 0; i < data.length; i++) {
     const char = data.charCodeAt(i);
     if (instr === false && char === quoteCode) instr = true;
     else if (
-      instr === true &&
-      char === quoteCode &&
-      data.charCodeAt(i - 1) !== backSlashCode
-    )
-      instr = false;
+      instr === true && char === quoteCode
+      && data.charCodeAt(i - 1) !== backSlashCode
+    ) instr = false;
 
     if (instr === false) {
       if (!isSpace(char)) result.write(data.charAt(i));
@@ -32,9 +28,8 @@ export function removeWhitespace(data: string): string {
   return result.toString();
 }
 
-// @ts-ignore
-@inline
-export function escapeChar(char: string): string {
+// @ts-ignore: Decorator
+@inline export function escapeChar(char: string): string {
   switch (unsafeCharCodeAt(char, 0)) {
     case 0x22:
       return '\\"';
@@ -63,143 +58,169 @@ export function escapeChar(char: string): string {
  * @returns depth of array
  */
 
-// @ts-ignore
-@inline
-export function getArrayDepth<T>(depth: i32 = 1): i32 {
-  // @ts-ignore
+// @ts-ignore: Decorator
+@inline export function getArrayDepth<T extends ArrayLike>(depth: i32 = 1): i32 {
   if (!isArray<T>()) {
     return 0;
-    // @ts-ignore
   } else if (isArray<valueof<T>>()) {
     depth++;
-    // @ts-ignore
     return getArrayDepth<valueof<T>>(depth);
   } else {
     return depth;
   }
 }
 
-// Scientific Notation Integer Parsing - SNIP
-// This is absolutely the fastest algorithm I could think of while adding full support for Scientific Notation
-// Loads 32 bits and retrieves the high/low bits
-// Here are some benchmarks
-// Parsing: "12345"
-// Results are spread over 5000ms
-// SNIP: 207M iterations
-// ATOI: 222M iterations
-// STD (parseInt): 162M iterations
-export function snip_fast<T extends number>(str: string, offset: u32 = 0): T {
-  let ch: u32 = load<u32>(changetype<usize>(str));
-  const h = ch & 0xFFFF;
-  if (h === 48) return 0 as T;
-  const isNegative = h === 45; // Check if the number is negative
-  let val: T = 0 as T;
-  const len = u32(str.length << 1);
-  if (isNegative) {
-    if ((ch >> 16) === 48) return -0 as T;
-    offset += 2;
-    if (len >= 4) {
-      // 32-bit route
-      for (; offset < (len - 3); offset += 4) {
-        ch = load<u32>(changetype<usize>(str) + <usize>offset);
-        const low = ch & 0xFFFF;
-        const high = ch >> 16;
-        // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
-        if (low > 57) {
-          // The first char (f) is E or e
-          // We push the offset up by two and apply the notation.
-          offset += 2;
-          let exp: i32 = atoi_fast<i32>(str, offset);
-          if (exp < 0) {
-            for (let i = 0; i < exp; i++) {
-              val = (val / 10) as T;
+/** Scientific Notation Integer Parsing - SNIP
+ * This is absolutely the fastest algorithm I could think of while adding full support for Scientific Notation
+ * Loads 32 bits and retrieves the high/low bits.
+ * The reason why we only load 4 bytes at a time is that numbers in the 32-bit range are 7 chars long at most.
+ * Using SIMD or 64 bit loads would only work well when parsing large 128+ numbers.
+ * 
+ * Here are some benchmarks
+ * Parsing: "12345" 
+ * Results are spread over 5000ms
+ * 
+ * SNIP: 270M iterations
+ * ATOI: 285M iterations
+ * ParseInt: 176M iterations 
+ * 
+ * @param str - Any number. Can include scientific notation.
+*/
+// @ts-ignore: Decorator
+@inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
+  if (isSigned<T>()) {
+    const firstChar: u32 = load<u16>(changetype<usize>(str));
+    if (firstChar === 48) return 0 as T;
+    const isNegative = firstChar === 45; // Check if the number is negative
+    let val: T = 0 as T;
+    if (len == 0) len = u32(str.length << 1);
+    if (isNegative) {
+      offset += 2;
+      if (len >= 4) {
+        // 32-bit route
+        for (; offset < (len - 3); offset += 4) {
+          const ch = load<u32>(changetype<usize>(str) + <usize>offset);
+          const low = ch & 0xFFFF;
+          const high = ch >> 16;
+          // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
+          if (low > 57) {
+            // The first char (f) is E or e
+            // We push the offset up by two and apply the notation.
+            if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            } else {
+              // Inlined this operation instead of using a loop
+              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
             }
-          } else {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) as T;
+          } else if (high > 57) {
+            // The first char (f) is E or e
+            // We push the offset up by two and apply the notation.
+            if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
+              return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            } else {
+              // Inlined this operation instead of using a loop
+              return -(val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
             }
+          } else {
+            val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
           }
-          return -val as T;
-        } else if (high > 57) {
+        }
+      }
+      // Finish up the remainder with 16 bits.
+      for (; offset < len; offset += 2) {
+        const ch = load<u16>(changetype<usize>(str) + <usize>offset);
+        // 9 is 57. E and e are larger. Assumes valid JSON.
+        if (ch > 57) {
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
-          offset += 4;
-          let exp: i32 = atoi_fast<i32>(str, offset);
-          if (exp < 0) {
-            for (let i = 0; i < exp; i++) {
-              val = (val / 10) as T;
-            }
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            return -(val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
           } else {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) as T;
-            }
+            // Inlined this operation instead of using a loop
+            return -(val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
           }
-          return -val as T;
         } else {
-          val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
+          val = (val * 10) + (ch - 48) as T;
         }
       }
-    }
-    // Finish up the remainder with 16 bits.
-    for (; offset < len; offset += 2) {
-      ch = load<u16>(changetype<usize>(str) + <usize>offset);
-      // 9 is 57. E and e are larger. Assumes valid JSON.
-      if (ch > 57) {
-        // The first char (f) is E or e
-        // We push the offset up by two and apply the notation.
-        offset += 2;
-        let exp: i32 = atoi_fast<i32>(str, offset);
-        if (exp < 0) {
-          for (let i = 0; i > exp; i--) {
-            val = (val / 10) as T;
+      return -val as T;
+    } else {
+      if (len >= 4) {
+        // Duplet 16 bit lane load
+        for (; offset < (len - 3); offset += 4) {
+          const ch = load<u32>(changetype<usize>(str) + <usize>offset);
+          const low = ch & 0xFFFF;
+          const high = ch >> 16;
+          // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
+          if (low > 57) {
+            // The first char (f) is E or e
+            // We push the offset up by two and apply the notation.
+            if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            } else {
+              // Inlined this operation instead of using a loop
+              return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
+            }
+          } else if (high > 57) {
+            if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
+              return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+            } else {
+              // Inlined this operation instead of using a loop
+              return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
+            }
+          } else {
+            // Optimized with multiplications and shifts.
+            val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
           }
-        } else {
-          for (let i = 0; i < exp; i++) {
-            val = (val * 10) as T;
+        }
+      }
+      // Cover the remaining numbers with 16 bit loads.
+      for (; offset < len; offset += 2) {
+        const ch = load<u16>(changetype<usize>(str) + <usize>offset);
+        // 0's char is 48 and 9 is 57. Anything above this range would signify an exponent (e or E).
+        // e is 101 and E is 69.
+        if (ch > 57) {
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            val = (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
+          } else {
+            // Inlined this operation instead of using a loop
+            val = (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
           }
+          return val as T;
+        } else {
+          val = (val * 10) + (ch - 48) as T;
         }
-        return -val as T;
-      } else {
-        val = (val * 10) + (ch - 48) as T;
       }
+      return val as T;
     }
-    return -val as T;
   } else {
+    const firstChar: u32 = load<u16>(changetype<usize>(str));
+    if (firstChar === 48) return 0 as T;
+    let val: T = 0 as T;
+    if (len == 0) len = u32(str.length << 1);
     if (len >= 4) {
       // Duplet 16 bit lane load
       for (; offset < (len - 3); offset += 4) {
-        ch = load<u32>(changetype<usize>(str) + <usize>offset);
+        const ch = load<u32>(changetype<usize>(str) + <usize>offset);
         const low = ch & 0xFFFF;
         const high = ch >> 16;
         // 9 is 57. The highest group of two numbers is 114, so if a e or an E is included, this will fire.
         if (low > 57) {
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
-          offset += 2;
-          let exp: i32 = atoi_fast<i32>(str, offset);
-          if (exp < 0) {
-            for (let i = 0; i < exp; i++) {
-              val = (val / 10) as T;
-            }
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
           } else {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) as T;
-            }
+            // Inlined this operation instead of using a loop
+            return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
           }
-          return val as T;
         } else if (high > 57) {
-          offset += 4;
-          let exp: i32 = atoi_fast<i32>(str, offset);
-          if (exp < 0) {
-            for (let i = 0; i < exp; i++) {
-              val = (val / 10) as T;
-            }
+          if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
+            return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
           } else {
-            for (let i = 0; i < exp; i++) {
-              val = (val * 10) as T;
-            }
+            // Inlined this operation instead of using a loop
+            return (val * (10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1))) as T;
           }
-          return val as T;
         } else {
           // Optimized with multiplications and shifts.
           val = (val * 100 + ((low - 48) * 10) + (high - 48)) as T;
@@ -208,22 +229,16 @@ export function snip_fast<T extends number>(str: string, offset: u32 = 0): T {
     }
     // Cover the remaining numbers with 16 bit loads.
     for (; offset < len; offset += 2) {
-      ch = load<u16>(changetype<usize>(str) + <usize>offset);
+      const ch = load<u16>(changetype<usize>(str) + <usize>offset);
       // 0's char is 48 and 9 is 57. Anything above this range would signify an exponent (e or E).
       // e is 101 and E is 69.
       if (ch > 57) {
-        offset += 2;
-        let exp: i32 = atoi_fast<i32>(str, offset);
-        if (exp < 0) {
-          for (let i = 0; i > exp; i--) {
-            val = (val / 10) as T;
-          }
+        if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
+          return (val / (10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1))) as T;
         } else {
-          for (let i = 0; i < exp; i++) {
-            val = (val * 10) as T;
-          }
+          // Inlined this operation instead of using a loop
+          return (val * (10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1))) as T;
         }
-        return val as T;
       } else {
         val = (val * 10) + (ch - 48) as T;
       }
@@ -234,34 +249,37 @@ export function snip_fast<T extends number>(str: string, offset: u32 = 0): T {
 
 /**
  * Implementation of ATOI. Can be much much faster with SIMD.
- * Benchmark: 40-46m ops/s
  */
 
 // @ts-ignore
-@inline
-export function atoi_fast<T extends number>(str: string, offset: u32 = 0): T {
+@global @inline export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
-  const len = u32(str.length << 1);
-  if (load<u16>(changetype<usize>(str) + <usize>offset) === 45) {
-    offset += 2;
-    for (; offset < len; offset += 2) {
-      // @ts-ignore
-      val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
+  if (!end) end = start + u32(str.length << 1);
+  if (isSigned<T>()) {
+    // Negative path
+    if (load<u16>(changetype<usize>(str) + <usize>start) === 45) {
+      start += 2;
+      for (; start < end; start += 2) {
+        val = (val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48) as T;
+      }
+      return -val as T;
+    } else {
+      for (; start < end; start += 2) {
+        val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+      }
+      return val as T;
     }
-    // @ts-ignore
-    return -val;
   } else {
-    for (; offset < len; offset += 2) {
-      // @ts-ignore
-      val = (val << 1) + (val << 3) + (load<u16>(changetype<usize>(str) + <usize>offset) - 48);
+    for (; start < end; start += 2) {
+      val = ((val * 10) + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
     }
-    return val;
+    return val as T;
   }
 }
 
 /**
- * Parses an integer using atoi_fast and applies the appended exponential number to it as scientific notation.
+ * Parses an integer using __atoi_fast and applies the appended exponential number to it as scientific notation.
  * Benchmark: Hovers around 30m ops/s
  * Only safe if the string is valid.
  * @param str integer to parse. example: 123e1, 123e-1, 123E100
@@ -269,8 +287,7 @@ export function atoi_fast<T extends number>(str: string, offset: u32 = 0): T {
  */
 
 // @ts-ignore
-@inline
-export function parseSciInteger<T extends number>(str: string): T {
+@inline export function parseSciInteger<T extends number>(str: string): T {
   // @ts-ignore
   let val: T = 0;
   let offset = 0;
@@ -284,12 +301,12 @@ export function parseSciInteger<T extends number>(str: string): T {
       const char = load<u16>(changetype<usize>(str) + <usize>(offset += 2));
       if (char === 45) {
         // @ts-ignore
-        val /= sciNote<T>(atoi_fast<T>(str, (offset += 2)));
+        val /= sciNote<T>(__atoi_fast<T>(str, (offset += 2)));
         // @ts-ignore
         return val;
       } else {
         // @ts-ignore
-        val *= sciNote<T>(atoi_fast<T>(str, offset));
+        val *= sciNote<T>(__atoi_fast<T>(str, offset));
         // @ts-ignore
         return val;
       }
@@ -299,25 +316,35 @@ export function parseSciInteger<T extends number>(str: string): T {
     // We use load because in this case, there is no need to have bounds-checking
   }
   if (firstChar === 45) {
-    val = -val;
+    val = -val as T;
   }
   return val;
 }
 
 // @ts-ignore
-@inline
-function sciNote<T extends number>(num: T): T {
+@inline function sciNote<T extends number>(num: T): T {
   let res = 1;
   // @ts-ignore
   if (num > 0) {
-    for (let i: T = 0; i < num; i++) {
+    for (let i: T = <T>0; i < num; i++) {
       res *= 10;
     }
   } else {
-    for (let i: T = 0; i < num; i++) {
+    for (let i: T = <T>0; i < num; i++) {
       res /= 10;
     }
   }
   // @ts-ignore
   return res;
+}
+
+// @ts-ignore
+@inline function equalsSlice(p1_data: string, p1_start: i32, p1_end: i32, p2_data: string, p2_start: i32, p2_end: i32): boolean {
+  const p1_len = p1_end - p1_start;
+  const p2_len = p2_end - p2_start;
+  if (p1_len != p2_len) return false;
+  if (p1_len == 2) {
+    return load<u16>(changetype<usize>(p1_data) + p1_start) == load<u16>(changetype<usize>(p2_data) + p2_start)
+  }
+  return memory.compare(changetype<usize>(p1_data) + p1_start, changetype<usize>(p2_data) + p2_start, p1_len) === 0;
 }

package/assembly/test.ts

@@ -1,89 +1,68 @@
-import { snip_fast } from "./src/util";
-
-import { JSON } from "./src/json";
+import { bench, blackbox } from "../../../WebAssembly/benchmark-wasm/assembly/bench";
+import { JSON, serializeString } from "./src/json";
+// @ts-ignore
 @json
 class Vec3 {
-  x!: f64;
-  y!: f64;
-  z!: f64;
+    x: f64;
+    y: f64;
+    z: f64;
 }
 
+// @ts-ignore
 @json
 class Player {
-  firstName!: string;
-  lastName!: string;
-  lastActive!: i32[];
-  age!: i32;
-  pos!: Vec3 | null;
-  isVerified!: boolean;
+    firstName: string;
+    lastName: string;
+    lastActive: i32[];
+    age: i32;
+    pos: Vec3 | null;
+    isVerified: boolean;
 }
 
-const player: Player = {
-  firstName: "Emmet",
-  lastName: "West",
-  lastActive: [8, 27, 2022],
-  age: 23,
-  pos: {
+const vec: Vec3 = {
     x: 3.4,
     y: 1.2,
     z: 8.3,
-  },
-  isVerified: true,
-};
-
-const vec: Vec3 = {
-  x: 3,
-  y: 1,
-  z: 8,
-};
+}
 
-function canSerde<T>(data: T, toBe: string = ""): void {
-  if (!toBe) toBe = JSON.stringify<T>(data);
-  const deserialized = JSON.stringify<T>(JSON.parse<T>(JSON.stringify(data)));
-  if (deserialized != toBe) {
-    console.log("Expected: " + toBe);
-    console.log("Actual:   " + deserialized);
-  } else {
-    console.log("Passed Test")
-  }
+const player: Player = {
+    firstName: "Emmet",
+    lastName: "West",
+    lastActive: [8, 27, 2022],
+    age: 23,
+    pos: {
+        x: 3.4,
+        y: 1.2,
+        z: 8.3,
+    },
+    isVerified: true,
 }
 
-canSerde<Player>({
-  firstName: "Emmet",
-  lastName: "West",
-  lastActive: [8, 27, 2022],
-  age: 23,
-  pos: {
-    x: 3.4,
-    y: 1.2,
-    z: 8.3,
-  },
-  isVerified: true,
-}, '{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}');
-const serializedPlayer = JSON.stringify<Player>(player);
-console.log(serializedPlayer);
-const parsedPlayer = JSON.parse<Player>(serializedPlayer);
-console.log(JSON.stringify(parsedPlayer));
+console.log("Original: " + JSON.stringify(vec));
+//console.log("Revised: " + vec.__JSON_Deserialize('{"x":3,"y":1,"z":8}').__JSON_Serialize());
+console.log("Implemented: " + JSON.stringify(JSON.parse<Vec3>('{"x":3.4,"y":1.2,"z":8.3}')));
+
+console.log("Original: " + JSON.stringify(player));
+//console.log("Revised: " + vec.__JSON_Deserialize('{"x":3,"y":1,"z":8}').__JSON_Serialize());
+console.log("Implemented: " + JSON.stringify(JSON.parse<Player>('{"firstName":"Emmet","lastName":"West","lastActive":[8,27,2022],"age":23,"pos":{"x":3.4,"y":1.2,"z":8.3},"isVerified":true}')));
+
+console.log("Serialized String: " + serializeString('st"ring" w""ith quotes"'));
 
-const serializedVec3 = JSON.stringify(vec);
-console.log(serializedVec3);
+bench("New Stringify String", () => {
+    blackbox<string>(serializeString(blackbox<string>('st"ring" w""ith quotes"')));
+});
+/*
+// 9,325,755
+bench("Stringify Object (Vec3)", () => {
+    blackbox<string>(vec.__JSON_Serialize());
+});
 
-const parsedVec3 = JSON.parse<Vec3>(serializedVec3);
-console.log(JSON.stringify(parsedVec3));
+// 17,747,531 -> 55,517,015
+/*bench("New Parse Object (Vec3)", () => {
+    blackbox<Vec3>(vec.__JSON_Deserialize(blackbox<string>('{"x":0,"y":0,"z":0}')));
+});
 
-console.log("snip:");
-console.log("1234 <-> " + snip_fast<i32>("1234").toString());
-console.log("-1234 <-> " + snip_fast<i32>("-1234").toString());
-console.log("12340 <-> " + snip_fast<i32>("1234e1").toString());
-console.log("123400 <-> " + snip_fast<i32>("1234e2").toString());
-console.log("1234000 <-> " + snip_fast<i32>("1234e3").toString());
-console.log("12 <-> " + snip_fast<i32>("123e-1").toString());
-console.log("123 <-> " + snip_fast<i32>("123").toString());
-console.log("-12340 <-> " + snip_fast<i32>("-1234e1").toString());
-console.log("-1234500 <-> " + snip_fast<i32>("-12345e2").toString());
-console.log("-123456000 <-> " + snip_fast<i32>("-123456e3").toString());
-console.log("-12 <-> " + snip_fast<i32>("-123e-1").toString());
-console.log("-123 <-> " + snip_fast<i32>("-123").toString());
-console.log(snip_fast<i32>("1000").toString());
-console.log(snip_fast<i32>("-1000").toString());
-console.log(JSON.stringify([[1, 2, 3, 4, 5], [5, 4, 3, 2, 1]]));
+// 17,747,531
+bench("Old Parse Object (Vec3)", () => {
+    blackbox<Vec3>(JSON.parse<Vec3>(blackbox<string>('{"x":3.4,"y":1.2,"z":8.3}')));
+});*/